package mandreelFile6;/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import java.util.Objects;

import static Class.CommonClassFile.commonVariable;
import static Class.CommonClassFile.heapClassInst;
import static Class.DevNumber.*;
import static commonFile.CommonFile.*;
import static mandreelFile3.mandreelFile3.*;
import static mandreelFile4.mandreelFile4.zn20btAlignedObjectArrayI9btElementE17quickSortInternalI31btUnionFindElementSortPredicateEEvTIi;
import static mandreelFile4.mandreelFile4.zn20btAlignedObjectArrayIP20btPersistentManifoldE17quickSortInternalI33btPersistentManifoldSortPredicateEEvTIi;
import static mandreelFile5.mandreelFile5.*;
import static mandreelFile7.mandreelFile7.zn4Rw10RwThrowEiz;
import static mandreelFile8.mandreelFile8.zn11btRigidBody14setupRigidBodyERKNS27btRigidBodyConstructionInfoE;
import static mandreelFile8.mandreelFile8.zn11btRigidBody19updateInertiaTensorEv;

public class mandreelFile6 {
    static void zn35btSequentialImpulseConstraintSolver36resolveSingleConstraintRowLowerLimitER11btRigidBodyS1RK18btSolverConstraint(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + numDefine2];
        r1 = r1 >> numDefine2;
        r0 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[fp + 1];
        r2 = r2 >> numDefine2;
        f0 = heapClassInst.heapFloat[r1 + numDefine4];
        f1 = heapClassInst.heapFloat[r0 + numDefine126];
        f2 = heapClassInst.heapFloat[r1 + numDefine5];
        f3 = heapClassInst.heapFloat[r0 + numDefine127];
        f4 = heapClassInst.heapFloat[r1];
        f5 = heapClassInst.heapFloat[r0 + numDefine130];
        f6 = heapClassInst.heapFloat[r1 + 1];
        f7 = heapClassInst.heapFloat[r0 + numDefine131];
        f8 = heapClassInst.heapFloat[r2 + numDefine126];
        f9 = heapClassInst.heapFloat[r2 + numDefine127];
        f10 = heapClassInst.heapFloat[r1 + numDefine6];
        f11 = heapClassInst.heapFloat[r0 + numDefine128];
        f1 = f0 * f1;
        f3 = f2 * f3;
        f4 = f4 * f5;
        f5 = f6 * f7;
        f6 = heapClassInst.heapFloat[r1 + numDefine2];
        f7 = heapClassInst.heapFloat[r0 + numDefine132];
        f12 = heapClassInst.heapFloat[r1 + numDefine8];
        f13 = heapClassInst.heapFloat[r2 + numDefine130];
        f14 = heapClassInst.heapFloat[r1 + numDefine9];
        f15 = heapClassInst.heapFloat[r2 + numDefine131];
        f16 = heapClassInst.heapFloat[r2 + numDefine128];
        f1 = f1 + f3;
        f3 = f10 * f11;
        f4 = f4 + f5;
        f5 = f6 * f7;
        f6 = f12 * f13;
        f7 = f14 * f15;
        f11 = heapClassInst.heapFloat[r1 + numDefine10];
        f12 = heapClassInst.heapFloat[r2 + numDefine132];
        f8 = f0 * f8;
        f9 = f2 * f9;
        f13 = heapClassInst.heapFloat[r1 + numDefine21];
        f14 = heapClassInst.heapFloat[r1 + numDefine30];
        f1 = f1 + f3;
        f3 = f4 + f5;
        f4 = f6 + f7;
        f5 = f11 * f12;
        f6 = f8 + f9;
        f7 = f10 * f16;
        f8 = heapClassInst.heapFloat[r1 + numDefine29];
        f9 = f13 * f14;
        f1 = f1 + f3;
        f3 = heapClassInst.heapFloat[r1 + numDefine23];
        f4 = f4 + f5;
        f5 = f6 + f7;
        f4 = f4 - f5;
        f5 = f8 - f9;
        f1 = f3 * f1;
        f1 = f5 - f1;
        f3 = f3 * f4;
        f1 = f1 - f3;
        f3 = heapClassInst.heapFloat[r1 + numDefine31];
        f4 = f13 + f1;
        if (f3 > f4) {
            f1 = f3 - f13;
            f4 = f3;
        }
        heapClassInst.heapFloat[r1 + numDefine21] = f4;
        f3 = heapClassInst.heapFloat[r0 + numDefine84];
        f4 = 0;
        if (!(f3 == f4)) {
            f3 = heapClassInst.heapFloat[r0 + numDefine138];
            f0 = f0 * f3;
            f0 = f0 * f1;
            f3 = heapClassInst.heapFloat[r0 + numDefine126];
            f5 = heapClassInst.heapFloat[r0 + numDefine139];
            f6 = heapClassInst.heapFloat[r0 + numDefine140];
            f0 = f3 + f0;
            f2 = f2 * f5;
            heapClassInst.heapFloat[r0 + numDefine126] = f0;
            f0 = f2 * f1;
            f2 = heapClassInst.heapFloat[r0 + numDefine127];
            f0 = f2 + f0;
            f2 = f10 * f6;
            heapClassInst.heapFloat[r0 + numDefine127] = f0;
            f0 = f2 * f1;
            f2 = heapClassInst.heapFloat[r0 + numDefine128];
            f0 = f2 + f0;
            heapClassInst.heapFloat[r0 + numDefine128] = f0;
            f0 = heapClassInst.heapFloat[r0 + numDefine134];
            f0 = f0 * f1;
            f2 = heapClassInst.heapFloat[r1 + numDefine12];
            f3 = heapClassInst.heapFloat[r0 + numDefine136];
            f5 = heapClassInst.heapFloat[r0 + numDefine135];
            f0 = f2 * f0;
            f2 = heapClassInst.heapFloat[r0 + numDefine130];
            f6 = heapClassInst.heapFloat[r1 + numDefine14];
            f7 = heapClassInst.heapFloat[r1 + numDefine13];
            f0 = f2 + f0;
            f2 = f5 * f1;
            heapClassInst.heapFloat[r0 + numDefine130] = f0;
            f0 = f7 * f2;
            f2 = heapClassInst.heapFloat[r0 + numDefine131];
            f0 = f2 + f0;
            f2 = f3 * f1;
            heapClassInst.heapFloat[r0 + numDefine131] = f0;
            f0 = f6 * f2;
            f2 = heapClassInst.heapFloat[r0 + numDefine132];
            f0 = f2 + f0;
            heapClassInst.heapFloat[r0 + numDefine132] = f0;
        }
        f0 = heapClassInst.heapFloat[r2 + numDefine84];
        if (!(f0 == f4)) {
            f0 = heapClassInst.heapFloat[r1 + numDefine4];
            f2 = heapClassInst.heapFloat[r2 + numDefine138];
            f0 = f2 * f0;
            f0 = f0 * f1;
            f2 = heapClassInst.heapFloat[r2 + numDefine126];
            f3 = heapClassInst.heapFloat[r1 + numDefine5];
            f4 = heapClassInst.heapFloat[r2 + numDefine139];
            f5 = heapClassInst.heapFloat[r1 + numDefine6];
            f6 = heapClassInst.heapFloat[r2 + numDefine140];
            f0 = f2 - f0;
            f2 = f4 * f3;
            heapClassInst.heapFloat[r2 + numDefine126] = f0;
            f0 = f2 * f1;
            f2 = heapClassInst.heapFloat[r2 + numDefine127];
            f0 = f2 - f0;
            f2 = f6 * f5;
            heapClassInst.heapFloat[r2 + numDefine127] = f0;
            f0 = f2 * f1;
            f2 = heapClassInst.heapFloat[r2 + numDefine128];
            f0 = f2 - f0;
            heapClassInst.heapFloat[r2 + numDefine128] = f0;
            f0 = heapClassInst.heapFloat[r2 + numDefine134];
            f0 = f0 * f1;
            f2 = heapClassInst.heapFloat[r1 + numDefine16];
            f3 = heapClassInst.heapFloat[r2 + numDefine136];
            f4 = heapClassInst.heapFloat[r2 + numDefine135];
            f0 = f2 * f0;
            f2 = heapClassInst.heapFloat[r2 + numDefine130];
            f5 = heapClassInst.heapFloat[r1 + numDefine18];
            f6 = heapClassInst.heapFloat[r1 + numDefine17];
            f0 = f2 + f0;
            f2 = f4 * f1;
            heapClassInst.heapFloat[r2 + numDefine130] = f0;
            f0 = f6 * f2;
            f2 = heapClassInst.heapFloat[r2 + numDefine131];
            f0 = f2 + f0;
            f1 = f3 * f1;
            heapClassInst.heapFloat[r2 + numDefine131] = f0;
            f0 = f5 * f1;
            f1 = heapClassInst.heapFloat[r2 + numDefine132];
            f0 = f1 + f0;
            heapClassInst.heapFloat[r2 + numDefine132] = f0;
        }
        return;
    }

    static void zn35btSequentialImpulseConstraintSolver43resolveSplitPenetrationImpulseCacheFriendlyER11btRigidBodyS1RK18btSolverConstraint(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine2];
        r0 = r0 >> numDefine2;
        f0 = heapClassInst.heapFloat[r0 + numDefine33];
        f1 = 0;
        if (!(f0 == f1)) {
            r1 = heapClassInst.heap32[fp];
            r2 = heapClassInst.heap32[fp + 1];
            r3 = gNumSplitImpulseRecoveries;
            r3 = r3 >> numDefine2;
            r4 = heapClassInst.heap32[r3];
            r4 = (r4 + 1) | 0;
            r1 = r1 >> numDefine2;
            heapClassInst.heap32[r3] = r4;
            r2 = r2 >> numDefine2;
            f2 = heapClassInst.heapFloat[r0 + numDefine4];
            f3 = heapClassInst.heapFloat[r1 + numDefine142];
            f4 = heapClassInst.heapFloat[r0 + numDefine5];
            f5 = heapClassInst.heapFloat[r1 + numDefine143];
            f6 = heapClassInst.heapFloat[r0];
            f7 = heapClassInst.heapFloat[r1 + numDefine146];
            f8 = heapClassInst.heapFloat[r0 + 1];
            f9 = heapClassInst.heapFloat[r1 + numDefine147];
            f10 = heapClassInst.heapFloat[r2 + numDefine142];
            f11 = heapClassInst.heapFloat[r2 + numDefine143];
            f12 = heapClassInst.heapFloat[r0 + numDefine6];
            f13 = heapClassInst.heapFloat[r1 + numDefine144];
            f3 = f2 * f3;
            f5 = f4 * f5;
            f6 = f6 * f7;
            f7 = f8 * f9;
            f8 = heapClassInst.heapFloat[r0 + numDefine2];
            f9 = heapClassInst.heapFloat[r1 + numDefine148];
            f14 = heapClassInst.heapFloat[r0 + numDefine8];
            f15 = heapClassInst.heapFloat[r2 + numDefine146];
            f16 = heapClassInst.heapFloat[r0 + numDefine9];
            f17 = heapClassInst.heapFloat[r2 + numDefine147];
            f18 = heapClassInst.heapFloat[r2 + numDefine144];
            f3 = f3 + f5;
            f5 = f12 * f13;
            f6 = f6 + f7;
            f7 = f8 * f9;
            f8 = f14 * f15;
            f9 = f16 * f17;
            f13 = heapClassInst.heapFloat[r0 + numDefine10];
            f14 = heapClassInst.heapFloat[r2 + numDefine148];
            f10 = f2 * f10;
            f11 = f4 * f11;
            f15 = heapClassInst.heapFloat[r0 + numDefine20];
            f16 = heapClassInst.heapFloat[r0 + numDefine30];
            f3 = f3 + f5;
            f5 = f6 + f7;
            f6 = f8 + f9;
            f7 = f13 * f14;
            f8 = f10 + f11;
            f9 = f12 * f18;
            f10 = f15 * f16;
            f3 = f3 + f5;
            f5 = heapClassInst.heapFloat[r0 + numDefine23];
            f6 = f6 + f7;
            f7 = f8 + f9;
            f6 = f6 - f7;
            f0 = f0 - f10;
            f3 = f5 * f3;
            f0 = f0 - f3;
            f3 = f5 * f6;
            f0 = f0 - f3;
            f3 = heapClassInst.heapFloat[r0 + numDefine31];
            f5 = f15 + f0;
            if (f3 > f5) {
                f0 = f3 - f15;
                f5 = f3;
            }
            heapClassInst.heapFloat[r0 + numDefine20] = f5;
            f3 = heapClassInst.heapFloat[r1 + numDefine84];
            if (!(f3 == f1)) {
                f3 = heapClassInst.heapFloat[r1 + numDefine138];
                f2 = f2 * f3;
                f2 = f2 * f0;
                f3 = heapClassInst.heapFloat[r1 + numDefine142];
                f5 = heapClassInst.heapFloat[r1 + numDefine139];
                f6 = heapClassInst.heapFloat[r1 + numDefine140];
                f2 = f3 + f2;
                f3 = f4 * f5;
                heapClassInst.heapFloat[r1 + numDefine142] = f2;
                f2 = f3 * f0;
                f3 = heapClassInst.heapFloat[r1 + numDefine143];
                f2 = f3 + f2;
                f3 = f12 * f6;
                heapClassInst.heapFloat[r1 + numDefine143] = f2;
                f2 = f3 * f0;
                f3 = heapClassInst.heapFloat[r1 + numDefine144];
                f2 = f3 + f2;
                heapClassInst.heapFloat[r1 + numDefine144] = f2;
                f2 = heapClassInst.heapFloat[r1 + numDefine134];
                f2 = f2 * f0;
                f3 = heapClassInst.heapFloat[r0 + numDefine12];
                f4 = heapClassInst.heapFloat[r1 + numDefine136];
                f5 = heapClassInst.heapFloat[r1 + numDefine135];
                f2 = f3 * f2;
                f3 = heapClassInst.heapFloat[r1 + numDefine146];
                f6 = heapClassInst.heapFloat[r0 + numDefine14];
                f7 = heapClassInst.heapFloat[r0 + numDefine13];
                f2 = f3 + f2;
                f3 = f5 * f0;
                heapClassInst.heapFloat[r1 + numDefine146] = f2;
                f2 = f7 * f3;
                f3 = heapClassInst.heapFloat[r1 + numDefine147];
                f2 = f3 + f2;
                f3 = f4 * f0;
                heapClassInst.heapFloat[r1 + numDefine147] = f2;
                f2 = f6 * f3;
                f3 = heapClassInst.heapFloat[r1 + numDefine148];
                f2 = f3 + f2;
                heapClassInst.heapFloat[r1 + numDefine148] = f2;
            }
            f2 = heapClassInst.heapFloat[r2 + numDefine84];
            if (!(f2 == f1)) {
                f1 = heapClassInst.heapFloat[r0 + numDefine4];
                f2 = heapClassInst.heapFloat[r2 + numDefine138];
                f1 = f2 * f1;
                f1 = f1 * f0;
                f2 = heapClassInst.heapFloat[r2 + numDefine142];
                f3 = heapClassInst.heapFloat[r0 + numDefine5];
                f4 = heapClassInst.heapFloat[r2 + numDefine139];
                f5 = heapClassInst.heapFloat[r0 + numDefine6];
                f6 = heapClassInst.heapFloat[r2 + numDefine140];
                f1 = f2 - f1;
                f2 = f4 * f3;
                heapClassInst.heapFloat[r2 + numDefine142] = f1;
                f1 = f2 * f0;
                f2 = heapClassInst.heapFloat[r2 + numDefine143];
                f1 = f2 - f1;
                f2 = f6 * f5;
                heapClassInst.heapFloat[r2 + numDefine143] = f1;
                f1 = f2 * f0;
                f2 = heapClassInst.heapFloat[r2 + numDefine144];
                f1 = f2 - f1;
                heapClassInst.heapFloat[r2 + numDefine144] = f1;
                f1 = heapClassInst.heapFloat[r2 + numDefine134];
                f1 = f1 * f0;
                f2 = heapClassInst.heapFloat[r0 + numDefine16];
                f3 = heapClassInst.heapFloat[r2 + numDefine136];
                f4 = heapClassInst.heapFloat[r2 + numDefine135];
                f1 = f2 * f1;
                f2 = heapClassInst.heapFloat[r2 + numDefine146];
                f5 = heapClassInst.heapFloat[r0 + numDefine18];
                f6 = heapClassInst.heapFloat[r0 + numDefine17];
                f1 = f2 + f1;
                f2 = f4 * f0;
                heapClassInst.heapFloat[r2 + numDefine146] = f1;
                f1 = f6 * f2;
                f2 = heapClassInst.heapFloat[r2 + numDefine147];
                f1 = f2 + f1;
                f0 = f3 * f0;
                heapClassInst.heapFloat[r2 + numDefine147] = f1;
                f0 = f5 * f0;
                f1 = heapClassInst.heapFloat[r2 + numDefine148];
                f0 = f1 + f0;
                heapClassInst.heapFloat[r2 + numDefine148] = f0;
            }
        }
        return;
    }

    static void z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        if (!(r0 == 0)) {
            r0 = r0 >> numDefine2;
            r1 = heapClassInst.heap32[r0 + numDefine45];
            if (r1 != 0) {
                r1 = heapClassInst.heap32[fp + 1];
                r1 = r1 >> numDefine2;
                f0 = heapClassInst.heapFloat[r1];
                f1 = heapClassInst.heapFloat[r0 + numDefine2];
                f2 = heapClassInst.heapFloat[r0 + 1];
                f3 = heapClassInst.heapFloat[r1 + 1];
                f4 = heapClassInst.heapFloat[r0 + numDefine6];
                f5 = heapClassInst.heapFloat[r0 + numDefine5];
                f6 = heapClassInst.heapFloat[r0 + numDefine3];
                f7 = heapClassInst.heapFloat[r0 + numDefine7];
                f8 = f2 * f0;
                f9 = f5 * f3;
                f10 = f1 * f0;
                f11 = f4 * f3;
                f12 = heapClassInst.heapFloat[r1 + numDefine2];
                f13 = heapClassInst.heapFloat[r0 + numDefine10];
                f14 = heapClassInst.heapFloat[r0 + numDefine9];
                f15 = heapClassInst.heapFloat[r0 + numDefine11];
                f8 = f8 + f9;
                f9 = f14 * f12;
                f10 = f10 + f11;
                f11 = f13 * f12;
                f0 = f6 * f0;
                f3 = f7 * f3;
                f8 = f8 + f9;
                f9 = heapClassInst.heapFloat[r0 + numDefine41];
                f10 = f10 + f11;
                f11 = heapClassInst.heapFloat[r0 + numDefine42];
                f0 = f0 + f3;
                f3 = f15 * f12;
                f8 = f8 * f9;
                f9 = f10 * f11;
                f10 = heapClassInst.heapFloat[r0 + numDefine43];
                f0 = f0 + f3;
                f0 = f0 * f10;
                f2 = f2 * f8;
                f1 = f1 * f9;
                f3 = f5 * f8;
                f4 = f4 * f9;
                f1 = f2 + f1;
                f2 = f6 * f0;
                f5 = f14 * f8;
                f6 = f13 * f9;
                f3 = f3 + f4;
                f4 = f7 * f0;
                f1 = f1 + f2;
                f2 = f5 + f6;
                f0 = f15 * f0;
                f3 = f3 + f4;
                heapClassInst.heapFloat[r1] = f1;
                f0 = f2 + f0;
                heapClassInst.heapFloat[r1 + 1] = f3;
                heapClassInst.heapFloat[r1 + numDefine2] = f0;
                heapClassInst.heap32[r1 + numDefine3] = 0;
                return;
            }
        }
        return;
    }

    public static void zn35btSequentialImpulseConstraintSolver5resetEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r0 + numDefine31] = 0;
        
    }

    public static void zn35btSequential(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine7];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine11];
        repeat1:
        do {
            if (!(r2 == 0)) {
                r2 = heapClassInst.heap32[fp];
                r0 = heapClassInst.heapU8[r0 + numDefine61];
                r3 = heapClassInst.heap32[r1 + numDefine5];
                r0 = r0 & 1;
                if (r0 != 0) {
                    if (!(r3 < 1)) {
                        r0 = 0;
                        repeat6:
                        while (true) {
                            r3 = r2 >> numDefine2;
                            r4 = heapClassInst.heap32[r3 + numDefine2];
                            if (!(r4 < 1)) {
                                r5 = 0;
                                repeat10:
                                while (true) {
                                    r6 = heapClassInst.heap32[r3 + numDefine19];
                                    r7 = r5 << numDefine2;
                                    r6 = (r6 + r7) | 0;
                                    r6 = r6 >> numDefine2;
                                    r6 = heapClassInst.heap32[r6];
                                    r6 = (r6 * numDefine136) | 0;
                                    r7 = heapClassInst.heap32[r3 + numDefine4];
                                    r6 = (r7 + r6) | 0;
                                    r7 = r6 >> numDefine2;
                                    r8 = heapClassInst.heap32[r7 + numDefine27];
                                    r7 = heapClassInst.heap32[r7 + numDefine26];
                                    heapClassInst.heap32[g0] = r7;
                                    heapClassInst.heap32[g0 + 1] = r8;
                                    heapClassInst.heap32[g0 + numDefine2] = r6;
                                    r5 = (r5 + 1) | 0;
                                    zn35btSequentialImpulseConstraintSolver43resolveSplitPenetrationImpulseCacheFriendlyER11btRigidBodyS1RK18btSolverConstraint(i7);
                                    if (!(r4 != r5)) {
                                        break repeat10;
                                    }
                                }
                            }
                            r0 = (r0 + 1) | 0;
                            r3 = heapClassInst.heap32[r1 + numDefine5];
                            if (r3 > r0) {
                                continue repeat6;
                            } else {
                                break repeat1;
                            }
                        }
                    }
                } else {
                    if (r3 > 0) {
                        r0 = 0;
                        repeat15:
                        while (true) {
                            r3 = r2 >> numDefine2;
                            r4 = heapClassInst.heap32[r3 + numDefine2];
                            if (!(r4 < 1)) {
                                r5 = 0;
                                repeat19:
                                while (true) {
                                    r6 = heapClassInst.heap32[r3 + numDefine19];
                                    r7 = r5 << numDefine2;
                                    r6 = (r6 + r7) | 0;
                                    r6 = r6 >> numDefine2;
                                    r6 = heapClassInst.heap32[r6];
                                    r6 = (r6 * numDefine136) | 0;
                                    r7 = heapClassInst.heap32[r3 + numDefine4];
                                    r6 = (r7 + r6) | 0;
                                    r7 = r6 >> numDefine2;
                                    r8 = heapClassInst.heap32[r7 + numDefine27];
                                    r7 = heapClassInst.heap32[r7 + numDefine26];
                                    heapClassInst.heap32[g0] = r7;
                                    heapClassInst.heap32[g0 + 1] = r8;
                                    heapClassInst.heap32[g0 + numDefine2] = r6;
                                    r5 = (r5 + 1) | 0;
                                    zn35btSequentialImpulseConstraintSolver43resolveSplitPenetrationImpulseCacheFriendlyER11btRigidBodyS1RK18btSolverConstraint(i7);
                                    if (!(r4 != r5)) {
                                        break repeat19;
                                    }
                                }
                            }
                            r0 = (r0 + 1) | 0;
                            r3 = heapClassInst.heap32[r1 + numDefine5];
                            if (r3 > r0) {
                                continue repeat15;
                            } else {
                                break repeat1;
                            }
                        }
                    }
                }
            }
        } while (false);
        
    }

    public static void zn35btSequentialImpulseConstraintSolverD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv35btSequentialImpulseConstraintSolver;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = heapClassInst.heap32[r2 + numDefine29];
        if (!(r1 == 0)) {
            r3 = heapClassInst.heapU8[r0 + numDefine120];
            if (!(r3 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine29] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine120] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine29] = 0;
        heapClassInst.heap32[r2 + numDefine27] = 0;
        heapClassInst.heap32[r2 + numDefine28] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine24];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine100];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine24] = 0;
        }
        heapClassInst.heap8[r0 + numDefine100] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine24] = 0;
        heapClassInst.heap32[r2 + numDefine22] = 0;
        heapClassInst.heap32[r2 + numDefine23] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine19];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine80];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine19] = 0;
        }
        heapClassInst.heap8[r0 + numDefine80] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine19] = 0;
        heapClassInst.heap32[r2 + numDefine17] = 0;
        heapClassInst.heap32[r2 + numDefine18] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine14];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine60];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine14] = 0;
        }
        heapClassInst.heap8[r0 + numDefine60] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine14] = 0;
        heapClassInst.heap32[r2 + numDefine12] = 0;
        heapClassInst.heap32[r2 + numDefine13] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine9];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine40];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine9] = 0;
        }
        heapClassInst.heap8[r0 + numDefine40] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine9] = 0;
        heapClassInst.heap32[r2 + numDefine7] = 0;
        heapClassInst.heap32[r2 + numDefine8] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine4];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine20];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine4] = 0;
        }
        heapClassInst.heap8[r0 + numDefine20] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine4] = 0;
        heapClassInst.heap32[r2 + numDefine2] = 0;
        heapClassInst.heap32[r2 + numDefine3] = 0;
        
    }

    public static void zn35btSequentialImpulseConstraintSolverD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv35btSequentialImpulseConstraintSolver;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = heapClassInst.heap32[r2 + numDefine29];
        if (!(r1 == 0)) {
            r3 = heapClassInst.heapU8[r0 + numDefine120];
            if (!(r3 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine29] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine120] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine29] = 0;
        heapClassInst.heap32[r2 + numDefine27] = 0;
        heapClassInst.heap32[r2 + numDefine28] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine24];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine100];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine24] = 0;
        }
        heapClassInst.heap8[r0 + numDefine100] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine24] = 0;
        heapClassInst.heap32[r2 + numDefine22] = 0;
        heapClassInst.heap32[r2 + numDefine23] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine19];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine80];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine19] = 0;
        }
        heapClassInst.heap8[r0 + numDefine80] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine19] = 0;
        heapClassInst.heap32[r2 + numDefine17] = 0;
        heapClassInst.heap32[r2 + numDefine18] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine14];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine60];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine14] = 0;
        }
        heapClassInst.heap8[r0 + numDefine60] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine14] = 0;
        heapClassInst.heap32[r2 + numDefine12] = 0;
        heapClassInst.heap32[r2 + numDefine13] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine9];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine40];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine9] = 0;
        }
        heapClassInst.heap8[r0 + numDefine40] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine9] = 0;
        heapClassInst.heap32[r2 + numDefine7] = 0;
        heapClassInst.heap32[r2 + numDefine8] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine4];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine20];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine4] = 0;
        }
        heapClassInst.heap8[r0 + numDefine20] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine4] = 0;
        heapClassInst.heap32[r2 + numDefine2] = 0;
        heapClassInst.heap32[r2 + numDefine3] = 0;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn35btSolver10Solve(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg48;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr450;
        r1 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[g0] = r0;
        zn15CProfileManager13StartProfileEPKc(i7);
        if (r1 != 0) {
            r0 = heapClassInst.heap32[fp + numDefine2];
            if (r0 != 0) {
                r2 = heapClassInst.heap32[fp];
                r3 = heapClassInst.heap32[fp + numDefine3];
                r4 = heapClassInst.heap32[fp + numDefine4];
                r5 = heapClassInst.heap32[fp + numDefine5];
                r6 = heapClassInst.heap32[fp + numDefine6];
                r7 = heapClassInst.heap32[fp + numDefine7];
                r8 = heapClassInst.heap32[fp + numDefine8];
                r9 = heapClassInst.heap32[fp + numDefine9];
                r10 = r2 >> numDefine2;
                r11 = heapClassInst.heap32[r10];
                r11 = r11 >> numDefine2;
                r11 = heapClassInst.heap32[r11 + numDefine8];
                heapClassInst.heap32[g0] = r2;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = r0;
                heapClassInst.heap32[g0 + numDefine3] = r3;
                heapClassInst.heap32[g0 + numDefine4] = r4;
                heapClassInst.heap32[g0 + numDefine5] = r5;
                heapClassInst.heap32[g0 + numDefine6] = r6;
                heapClassInst.heap32[g0 + numDefine7] = r7;
                heapClassInst.heap32[g0 + numDefine8] = r8;
                heapClassInst.heap32[g0 + numDefine9] = r9;
                functionTable.get(r11 >> numDefine2).accept(i7);
                r11 = heapClassInst.heap32[r10];
                r11 = r11 >> numDefine2;
                r11 = heapClassInst.heap32[r11 + numDefine9];
                heapClassInst.heap32[g0] = r2;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = r0;
                heapClassInst.heap32[g0 + numDefine3] = r3;
                heapClassInst.heap32[g0 + numDefine4] = r4;
                heapClassInst.heap32[g0 + numDefine5] = r5;
                heapClassInst.heap32[g0 + numDefine6] = r6;
                heapClassInst.heap32[g0 + numDefine7] = r7;
                heapClassInst.heap32[g0 + numDefine8] = r8;
                heapClassInst.heap32[g0 + numDefine9] = r9;
                functionTable.get(r11 >> numDefine2).accept(i7);
                r10 = heapClassInst.heap32[r10];
                r10 = r10 >> numDefine2;
                r10 = heapClassInst.heap32[r10 + numDefine7];
                heapClassInst.heap32[g0] = r2;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = r0;
                heapClassInst.heap32[g0 + numDefine3] = r3;
                heapClassInst.heap32[g0 + numDefine4] = r4;
                heapClassInst.heap32[g0 + numDefine5] = r5;
                heapClassInst.heap32[g0 + numDefine6] = r6;
                heapClassInst.heap32[g0 + numDefine7] = r7;
                heapClassInst.heap32[g0 + numDefine8] = r8;
                heapClassInst.heap32[g0 + numDefine9] = r9;
                r0 = zn15CProfileManager11CurrentNodeE;
                r0 = r0 >> numDefine2;
                functionTable.get(r10 >> numDefine2).accept(i7);
                r1 = heapClassInst.heap32[r0];
                r2 = r1 >> numDefine2;
                r3 = heapClassInst.heap32[r2 + numDefine4];
                r3 = (r3 + -1) | 0;
                heapClassInst.heap32[r2 + numDefine4] = r3;
                repeat5:
                do {
                    if (!(r3 != 0)) {
                        r3 = heapClassInst.heap32[r2 + 1];
                        if (r3 != 0) {
                            r1 = sp + numDefineNeg8;
                            heapClassInst.heap32[g0] = r1;
                            heapClassInst.heap32[g0 + 1] = 0;
                            r3 = zl13gProfileClock2E0;
                            getTimeOfDay(i7);
                            r3 = r3 >> numDefine2;
                            r3 = heapClassInst.heap32[r3];
                            r3 = r3 >> numDefine2;
                            r1 = r1 >> numDefine2;
                            r4 = heapClassInst.heap32[fp + numDefineNeg2];
                            r5 = heapClassInst.heap32[r3];
                            r4 = (r4 - r5) | 0;
                            r1 = heapClassInst.heap32[r1 + 1];
                            r3 = heapClassInst.heap32[r3 + 1];
                            r1 = (r1 - r3) | 0;
                            r3 = (int) ((r4 * numDefineN6) | 0);
                            r1 = (r1 + r3) | 0;
                            r3 = heapClassInst.heap32[r2 + numDefine3];
                            r1 = (r1 - r3) | 0;
                            f0 = uint(r1);
                            f1 = numDefine1000;
                            f2 = heapClassInst.heapFloat[r2 + numDefine2];
                            f0 = f0 / f1;
                            f0 = f2 + f0;
                            heapClassInst.heapFloat[r2 + numDefine2] = f0;
                            r1 = heapClassInst.heap32[r2 + numDefine4];
                            if (r1 != 0) {
                                break repeat5;
                            } else {
                                r1 = heapClassInst.heap32[r0];
                            }
                        }
                        r1 = r1 >> numDefine2;
                        r1 = heapClassInst.heap32[r1 + numDefine5];
                        heapClassInst.heap32[r0] = r1;
                    }
                } while (false);
                f0 = 0;
                commonVariable.fg0 = f0;
                
            } else {
                r0 = twoEStr753;
                r1 = twoEStr652;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine1186;
                assertNew(i7);
            }
        } else {
            r1 = twoEStr551;
            r0 = twoEStr652;
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = r0;
            heapClassInst.heap32[g0 + numDefine2] = numDefine1185;
            assertNew(i7);
        }
        
    }

    public static void zn35btSFriendly(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg504;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[fp + 1];
        r3 = heapClassInst.heap32[fp + numDefine2];
        r4 = heapClassInst.heap32[fp + numDefine7];
        r5 = heapClassInst.heap32[r1 + numDefine2];
        r6 = 0;
        repeat1:
        while (true) {
            if (r6 < r5) {
                r7 = (r6 * numDefine34) | 0;
                r8 = heapClassInst.heap32[r1 + numDefine4];
                r7 = r7 << numDefine2;
                r7 = (r8 + r7) | 0;
                r7 = r7 >> numDefine2;
                r8 = heapClassInst.heap32[r7 + numDefine28];
                if (r8 != 0) {
                    r8 = r8 >> numDefine2;
                    heapClassInst.heap32[r8 + numDefine28] = heapClassInst.heap32[r7 + numDefine21];
                    r9 = heapClassInst.heapU8[r4 + numDefine60];
                    r9 = r9 & numDefine8;
                    if (!(r9 == 0)) {
                        r9 = heapClassInst.heap32[r7 + numDefine25];
                        r10 = heapClassInst.heap32[r1 + numDefine14];
                        r9 = (r9 * numDefine136) | 0;
                        r9 = (r10 + r9) | 0;
                        r9 = r9 >> numDefine2;
                        heapClassInst.heap32[r8 + numDefine30] = heapClassInst.heap32[r9 + numDefine21];
                        r7 = heapClassInst.heap32[r7 + numDefine25];
                        r9 = heapClassInst.heap32[r1 + numDefine14];
                        r7 = (r7 * numDefine136) | 0;
                        r7 = (r7 + r9) | 0;
                        r7 = r7 >> numDefine2;
                        heapClassInst.heap32[r8 + numDefine31] = heapClassInst.heap32[r7 + numDefine55];
                    }
                    r6 = (r6 + 1) | 0;
                    continue repeat1;
                } else {
                    label = numDefine2;
                    break repeat1;
                }
            } else {
                label = numDefine7;
                break repeat1;
            }
        }
        switch (label) {
            case numDefine7:
                r5 = heapClassInst.heap32[r1 + numDefine7];
                repeat10:
                do {
                    if (!(r5 < 1)) {
                        r6 = 0;
                        repeat12:
                        while (true) {
                            r7 = (r6 * numDefine34) | 0;
                            r8 = heapClassInst.heap32[r1 + numDefine9];
                            r7 = r7 << numDefine2;
                            r7 = (r8 + r7) | 0;
                            r7 = r7 >> numDefine2;
                            r8 = heapClassInst.heap32[r7 + numDefine28];
                            r8 = r8 >> numDefine2;
                            f0 = heapClassInst.heapFloat[r8 + numDefine7];
                            f1 = heapClassInst.heapFloat[r7 + numDefine21];
                            r6 = (r6 + 1) | 0;
                            f0 = f1 + f0;
                            heapClassInst.heapFloat[r8 + numDefine7] = f0;
                            if (r5 != r6) {
                                continue repeat12;
                            } else {
                                break repeat10;
                            }
                        }
                    }
                } while (false);
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4 + numDefine11];
                repeat15:
                do {
                    if (r5 != 0) {
                        if (!(r3 < 1)) {
                            label = numDefine13;
                            repeat17:
                            while (true) {
                                r5 = r2 >> numDefine2;
                                r5 = heapClassInst.heap32[r5];
                                r6 = heapClassInst.heapU8[r5 + numDefine232];
                                r6 = r6 & numDefine2;
                                if (!(r6 == 0)) {
                                    if (!(r5 == 0)) {
                                        r6 = r5 >> numDefine2;
                                        f0 = heapClassInst.heapFloat[r6 + numDefine84];
                                        f1 = 0;
                                        if (!(f0 == f1)) {
                                            f0 = heapClassInst.heapFloat[r4 + numDefine3];
                                            f1 = heapClassInst.heapFloat[r6 + numDefine78];
                                            f2 = heapClassInst.heapFloat[r6 + numDefine128];
                                            f3 = heapClassInst.heapFloat[r6 + numDefine77];
                                            f4 = heapClassInst.heapFloat[r6 + numDefine127];
                                            f5 = heapClassInst.heapFloat[r6 + numDefine76];
                                            f6 = heapClassInst.heapFloat[r6 + numDefine126];
                                            f5 = f5 + f6;
                                            f3 = f3 + f4;
                                            heapClassInst.heapFloat[r6 + numDefine76] = f5;
                                            f1 = f1 + f2;
                                            heapClassInst.heapFloat[r6 + numDefine77] = f3;
                                            heapClassInst.heapFloat[r6 + numDefine78] = f1;
                                            heapClassInst.heap32[r6 + numDefine79] = 0;
                                            f1 = heapClassInst.heapFloat[r6 + numDefine82];
                                            f2 = heapClassInst.heapFloat[r6 + numDefine132];
                                            f3 = heapClassInst.heapFloat[r6 + numDefine81];
                                            f4 = heapClassInst.heapFloat[r6 + numDefine131];
                                            f5 = heapClassInst.heapFloat[r6 + numDefine80];
                                            f6 = heapClassInst.heapFloat[r6 + numDefine130];
                                            f5 = f5 + f6;
                                            f3 = f3 + f4;
                                            heapClassInst.heapFloat[r6 + numDefine80] = f5;
                                            f1 = f1 + f2;
                                            heapClassInst.heapFloat[r6 + numDefine81] = f3;
                                            heapClassInst.heapFloat[r6 + numDefine82] = f1;
                                            heapClassInst.heap32[r6 + numDefine83] = 0;
                                            f1 = heapClassInst.heapFloat[r6 + numDefine142];
                                            f2 = heapClassInst.heapFloat[r6 + numDefine143];
                                            f3 = heapClassInst.heapFloat[r6 + numDefine144];
                                            r7 = sp + numDefineNeg64;
                                            r8 = (r5 + numDefine4) | 0;
                                            r5 = (r5 + numDefine584) | 0;
                                            heapClassInst.heap32[g0] = r8;
                                            heapClassInst.heapFloat[g0 + 1] = f1;
                                            heapClassInst.heapFloat[g0 + numDefine2] = f2;
                                            heapClassInst.heapFloat[g0 + numDefine3] = f3;
                                            heapClassInst.heap32[g0 + numDefine4] = r5;
                                            heapClassInst.heapFloat[g0 + numDefine5] = f0;
                                            heapClassInst.heap32[g0 + numDefine6] = r7;
                                            zn15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5FRS0(i7);
                                            r5 = r7 >> numDefine2;
                                            heapClassInst.heap32[r6 + 1] = heapClassInst.heap32[fp + numDefineNeg16];
                                            heapClassInst.heap32[r6 + numDefine2] = heapClassInst.heap32[r5 + 1];
                                            heapClassInst.heap32[r6 + numDefine3] = heapClassInst.heap32[r5 + numDefine2];
                                            heapClassInst.heap32[r6 + numDefine4] = heapClassInst.heap32[r5 + numDefine3];
                                            heapClassInst.heap32[r6 + numDefine5] = heapClassInst.heap32[r5 + numDefine4];
                                            heapClassInst.heap32[r6 + numDefine6] = heapClassInst.heap32[r5 + numDefine5];
                                            heapClassInst.heap32[r6 + numDefine7] = heapClassInst.heap32[r5 + numDefine6];
                                            heapClassInst.heap32[r6 + numDefine8] = heapClassInst.heap32[r5 + numDefine7];
                                            heapClassInst.heap32[r6 + numDefine9] = heapClassInst.heap32[r5 + numDefine8];
                                            heapClassInst.heap32[r6 + numDefine10] = heapClassInst.heap32[r5 + numDefine9];
                                            heapClassInst.heap32[r6 + numDefine11] = heapClassInst.heap32[r5 + numDefine10];
                                            heapClassInst.heap32[r6 + numDefine12] = heapClassInst.heap32[r5 + numDefine11];
                                            heapClassInst.heap32[r6 + numDefine13] = heapClassInst.heap32[r5 + numDefine12];
                                            heapClassInst.heap32[r6 + numDefine14] = heapClassInst.heap32[r5 + numDefine13];
                                            heapClassInst.heap32[r6 + numDefine15] = heapClassInst.heap32[r5 + numDefine14];
                                            heapClassInst.heap32[r6 + numDefine16] = heapClassInst.heap32[r5 + numDefine15];
                                        }
                                    }
                                }
                                r3 = (r3 + -1) | 0;
                                r2 = (r2 + numDefine4) | 0;
                                if (r3 == 0) {
                                    break repeat15;
                                } else {
                                    continue repeat17;
                                }
                            }
                        }
                    } else {
                        if (!(r3 < 1)) {
                            label = numDefine18;
                            repeat25:
                            while (true) {
                                r4 = r2 >> numDefine2;
                                r4 = heapClassInst.heap32[r4];
                                r5 = heapClassInst.heapU8[r4 + numDefine232];
                                r5 = r5 & numDefine2;
                                if (!(r5 == 0)) {
                                    if (!(r4 == 0)) {
                                        r4 = r4 >> numDefine2;
                                        f0 = heapClassInst.heapFloat[r4 + numDefine84];
                                        f1 = 0;
                                        if (!(f0 == f1)) {
                                            f0 = heapClassInst.heapFloat[r4 + numDefine78];
                                            f1 = heapClassInst.heapFloat[r4 + numDefine128];
                                            f2 = heapClassInst.heapFloat[r4 + numDefine77];
                                            f3 = heapClassInst.heapFloat[r4 + numDefine127];
                                            f4 = heapClassInst.heapFloat[r4 + numDefine76];
                                            f5 = heapClassInst.heapFloat[r4 + numDefine126];
                                            f4 = f4 + f5;
                                            f2 = f2 + f3;
                                            heapClassInst.heapFloat[r4 + numDefine76] = f4;
                                            f0 = f0 + f1;
                                            heapClassInst.heapFloat[r4 + numDefine77] = f2;
                                            heapClassInst.heapFloat[r4 + numDefine78] = f0;
                                            heapClassInst.heap32[r4 + numDefine79] = 0;
                                            f0 = heapClassInst.heapFloat[r4 + numDefine82];
                                            f1 = heapClassInst.heapFloat[r4 + numDefine132];
                                            f2 = heapClassInst.heapFloat[r4 + numDefine81];
                                            f3 = heapClassInst.heapFloat[r4 + numDefine131];
                                            f4 = heapClassInst.heapFloat[r4 + numDefine80];
                                            f5 = heapClassInst.heapFloat[r4 + numDefine130];
                                            f4 = f4 + f5;
                                            f2 = f2 + f3;
                                            heapClassInst.heapFloat[r4 + numDefine80] = f4;
                                            f0 = f0 + f1;
                                            heapClassInst.heapFloat[r4 + numDefine81] = f2;
                                            heapClassInst.heapFloat[r4 + numDefine82] = f0;
                                            heapClassInst.heap32[r4 + numDefine83] = 0;
                                        }
                                    }
                                }
                                r3 = (r3 + -1) | 0;
                                r2 = (r2 + numDefine4) | 0;
                                if (r3 != 0) {
                                    continue repeat25;
                                } else {
                                    break repeat15;
                                }
                            }
                        }
                    }
                } while (false);
                r2 = heapClassInst.heap32[r1 + numDefine2];
                repeat33:
                do {
                    if (!(r2 > -1)) {
                        r3 = heapClassInst.heap32[r1 + numDefine3];
                        if (!(r3 > -1)) {
                            r3 = heapClassInst.heap32[r1 + numDefine4];
                            if (!(r3 == 0)) {
                                r4 = heapClassInst.heapU8[r0 + numDefine20];
                                if (!(r4 == 0)) {
                                    r4 = gNumAlignedFree;
                                    r4 = r4 >> numDefine2;
                                    r5 = heapClassInst.heap32[r4];
                                    r5 = (r5 + 1) | 0;
                                    r3 = r3 >> numDefine2;
                                    heapClassInst.heap32[r4] = r5;
                                    r3 = heapClassInst.heap32[r3 + -1];
                                    heapClassInst.heap32[g0] = r3;
                                    free(i7);
                                }
                                heapClassInst.heap32[r1 + numDefine4] = 0;
                            }
                            r3 = 1;
                            heapClassInst.heap8[r0 + numDefine20] = (byte) r3;
                            heapClassInst.heap32[r1 + numDefine4] = 0;
                            heapClassInst.heap32[r1 + numDefine3] = 0;
                        }
                        r3 = (r2 * numDefine136) | 0;
                        repeat44:
                        while (true) {
                            r4 = heapClassInst.heap32[r1 + numDefine4];
                            r4 = (r4 + r3) | 0;
                            r5 = sp + numDefineNeg472;
                            heapClassInst.heap32[g0] = r4;
                            heapClassInst.heap32[g0 + 1] = r5;
                            heapClassInst.heap32[g0 + numDefine2] = numDefine136;
                            r2 = (r2 + 1) | 0;
                            r3 = (r3 + numDefine136) | 0;
                            memcpy(i7);
                            if (r2 != 0) {
                                continue repeat44;
                            } else {
                                break repeat33;
                            }
                        }
                    }
                } while (false);
                heapClassInst.heap32[r1 + numDefine2] = 0;
                r2 = heapClassInst.heap32[r1 + numDefine7];
                repeat47:
                do {
                    if (!(r2 > -1)) {
                        r3 = heapClassInst.heap32[r1 + numDefine8];
                        if (!(r3 > -1)) {
                            r3 = heapClassInst.heap32[r1 + numDefine9];
                            if (!(r3 == 0)) {
                                r4 = heapClassInst.heapU8[r0 + numDefine40];
                                if (!(r4 == 0)) {
                                    r4 = gNumAlignedFree;
                                    r4 = r4 >> numDefine2;
                                    r5 = heapClassInst.heap32[r4];
                                    r5 = (r5 + 1) | 0;
                                    r3 = r3 >> numDefine2;
                                    heapClassInst.heap32[r4] = r5;
                                    r3 = heapClassInst.heap32[r3 + -1];
                                    heapClassInst.heap32[g0] = r3;
                                    free(i7);
                                }
                                heapClassInst.heap32[r1 + numDefine9] = 0;
                            }
                            r3 = 1;
                            heapClassInst.heap8[r0 + numDefine40] = (byte) r3;
                            heapClassInst.heap32[r1 + numDefine9] = 0;
                            heapClassInst.heap32[r1 + numDefine8] = 0;
                        }
                        r3 = (r2 * numDefine136) | 0;
                        repeat58:
                        while (true) {
                            r4 = heapClassInst.heap32[r1 + numDefine9];
                            r4 = (r4 + r3) | 0;
                            r5 = sp + numDefineNeg336;
                            heapClassInst.heap32[g0] = r4;
                            heapClassInst.heap32[g0 + 1] = r5;
                            heapClassInst.heap32[g0 + numDefine2] = numDefine136;
                            r2 = (r2 + 1) | 0;
                            r3 = (r3 + numDefine136) | 0;
                            memcpy(i7);
                            if (r2 != 0) {
                                continue repeat58;
                            } else {
                                break repeat47;
                            }
                        }
                    }
                } while (false);
                heapClassInst.heap32[r1 + numDefine7] = 0;
                r2 = heapClassInst.heap32[r1 + numDefine12];
                repeat61:
                do {
                    if (!(r2 > -1)) {
                        r3 = heapClassInst.heap32[r1 + numDefine13];
                        if (!(r3 > -1)) {
                            r3 = heapClassInst.heap32[r1 + numDefine14];
                            if (!(r3 == 0)) {
                                r4 = heapClassInst.heapU8[r0 + numDefine60];
                                if (!(r4 == 0)) {
                                    r4 = gNumAlignedFree;
                                    r4 = r4 >> numDefine2;
                                    r5 = heapClassInst.heap32[r4];
                                    r5 = (r5 + 1) | 0;
                                    r3 = r3 >> numDefine2;
                                    heapClassInst.heap32[r4] = r5;
                                    r3 = heapClassInst.heap32[r3 + -1];
                                    heapClassInst.heap32[g0] = r3;
                                    free(i7);
                                }
                                heapClassInst.heap32[r1 + numDefine14] = 0;
                            }
                            r3 = 1;
                            heapClassInst.heap8[r0 + numDefine60] = (byte) r3;
                            heapClassInst.heap32[r1 + numDefine14] = 0;
                            heapClassInst.heap32[r1 + numDefine13] = 0;
                        }
                        r0 = (r2 * numDefine136) | 0;
                        repeat72:
                        while (true) {
                            r3 = heapClassInst.heap32[r1 + numDefine14];
                            r3 = (r3 + r0) | 0;
                            r4 = sp + numDefineNeg200;
                            heapClassInst.heap32[g0] = r3;
                            heapClassInst.heap32[g0 + 1] = r4;
                            heapClassInst.heap32[g0 + numDefine2] = numDefine136;
                            r2 = (r2 + 1) | 0;
                            r0 = (r0 + numDefine136) | 0;
                            memcpy(i7);
                            if (r2 != 0) {
                                continue repeat72;
                            } else {
                                break repeat61;
                            }
                        }
                    }
                } while (false);
                heapClassInst.heap32[r1 + numDefine12] = 0;
                f0 = 0;
                commonVariable.fg0 = f0;
                
            case numDefine2:
                r0 = twoEStr955;
                r1 = twoEStr652;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine1129;
                assertNew(i7);
                break;
            default:
                break;
        }
        
    }

    public static void zn35btsConstraint(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        int r19 = 0;
        int r20 = 0;
        int r21 = 0;
        int r22 = 0;
        int r23 = 0;
        int r24 = 0;
        int r25 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        float f28 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg584;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr1056;
        r1 = heapClassInst.heap32[fp + numDefine6];
        heapClassInst.heap32[g0] = r0;
        r0 = heapClassInst.heap32[fp + numDefine4];
        heapClassInst.heap32[fp + numDefineNeg133] = r0;
        r2 = 0;
        zn15CProfileManager13StartProfileEPKc(i7);
        r0 = (r2 - r0) | 0;
        repeat1:
        do {
            if (!(r1 == r0)) {
                r0 = heapClassInst.heap32[fp];
                r3 = heapClassInst.heap32[fp + 1];
                r4 = heapClassInst.heap32[fp + numDefine2];
                r5 = heapClassInst.heap32[fp + numDefine3];
                heapClassInst.heap32[fp + numDefineNeg132] = r5;
                r5 = heapClassInst.heap32[fp + numDefine5];
                heapClassInst.heap32[fp + numDefineNeg127] = r5;
                r5 = heapClassInst.heap32[fp + numDefine7];
                r6 = r5 >> numDefine2;
                r7 = heapClassInst.heap32[r6 + numDefine11];
                repeat3:
                do {
                    if (r7 != 0) {
                        if (!(r4 < 1)) {
                            label = numDefine4;
                            repeat5:
                            while (true) {
                                r7 = r3 >> numDefine2;
                                r7 = heapClassInst.heap32[r7];
                                r8 = heapClassInst.heapU8[r7 + numDefine232];
                                r8 = r8 & numDefine2;
                                if (!(r8 == 0)) {
                                    if (!(r7 == 0)) {
                                        r7 = r7 >> numDefine2;
                                        heapClassInst.heap32[r7 + numDefine126] = 0;
                                        heapClassInst.heap32[r7 + numDefine127] = 0;
                                        heapClassInst.heap32[r7 + numDefine128] = 0;
                                        heapClassInst.heap32[r7 + numDefine129] = 0;
                                        heapClassInst.heap32[r7 + numDefine130] = 0;
                                        heapClassInst.heap32[r7 + numDefine131] = 0;
                                        heapClassInst.heap32[r7 + numDefine132] = 0;
                                        heapClassInst.heap32[r7 + numDefine133] = 0;
                                        heapClassInst.heap32[r7 + numDefine142] = 0;
                                        heapClassInst.heap32[r7 + numDefine143] = 0;
                                        heapClassInst.heap32[r7 + numDefine144] = 0;
                                        heapClassInst.heap32[r7 + numDefine145] = 0;
                                        heapClassInst.heap32[r7 + numDefine146] = 0;
                                        heapClassInst.heap32[r7 + numDefine147] = 0;
                                        heapClassInst.heap32[r7 + numDefine148] = 0;
                                        heapClassInst.heap32[r7 + numDefine149] = 0;
                                    }
                                }
                                r4 = (r4 + -1) | 0;
                                r3 = (r3 + numDefine4) | 0;
                                if (r4 == 0) {
                                    break repeat3;
                                } else {
                                    continue repeat5;
                                }
                            }
                        }
                    } else {
                        if (!(r4 < 1)) {
                            label = numDefine8;
                            while (true) {
                                r7 = r3 >> numDefine2;
                                r7 = heapClassInst.heap32[r7];
                                r8 = heapClassInst.heapU8[r7 + numDefine232];
                                r8 = r8 & numDefine2;
                                if (!(r8 == 0)) {
                                    if (!(r7 == 0)) {
                                        r7 = r7 >> numDefine2;
                                        heapClassInst.heap32[r7 + numDefine126] = 0;
                                        heapClassInst.heap32[r7 + numDefine127] = 0;
                                        heapClassInst.heap32[r7 + numDefine128] = 0;
                                        heapClassInst.heap32[r7 + numDefine129] = 0;
                                        heapClassInst.heap32[r7 + numDefine130] = 0;
                                        heapClassInst.heap32[r7 + numDefine131] = 0;
                                        heapClassInst.heap32[r7 + numDefine132] = 0;
                                        heapClassInst.heap32[r7 + numDefine133] = 0;
                                    }
                                }
                                r4 = (r4 + -1) | 0;
                                r3 = (r3 + numDefine4) | 0;
                                if (r4 == 0) {
                                    break repeat3;
                                }
                            }
                        }
                    }
                } while (false);
                repeat19:
                do {
                    if (r1 < 1) {
                        r4 = r0 >> numDefine2;
                        r3 = heapClassInst.heap32[r4 + numDefine27];
                        repeat21:
                        do {
                            if (!(r3 > r1)) {
                                if (!(r3 >= r1)) {
                                    r7 = heapClassInst.heap32[r4 + numDefine28];
                                    if (!(r7 >= r1)) {
                                        if (r1 != 0) {
                                            r7 = gNumAlignedAllocs;
                                            r7 = r7 >> numDefine2;
                                            r8 = heapClassInst.heap32[r7];
                                            r9 = r1 << numDefine3;
                                            r8 = (r8 + 1) | 0;
                                            r9 = r9 | numDefine3;
                                            heapClassInst.heap32[r7] = r8;
                                            r7 = (r9 + numDefine16) | 0;
                                            heapClassInst.heap32[g0] = r7;
                                            mallocNew(i7);
                                            r7 = commonVariable.rg0;
                                            if (r7 != 0) {
                                                r8 = (r7 + numDefine4) | 0;
                                                r8 = (r2 - r8) | 0;
                                                r8 = r8 & numDefine15;
                                                r8 = (r7 + r8) | 0;
                                                r9 = (r8 + numDefine4) | 0;
                                                r8 = r8 >> numDefine2;
                                                heapClassInst.heap32[r8] = r7;
                                                r7 = r9;
                                            }
                                        } else {
                                            r7 = 0;
                                        }
                                        r8 = (r0 + numDefine116) | 0;
                                        if (r3 < 1) {
                                            r2 = r8 >> numDefine2;
                                            r9 = heapClassInst.heap32[r2];
                                        } else {
                                            repeat33:
                                            while (true) {
                                                r9 = r8 >> numDefine2;
                                                r9 = heapClassInst.heap32[r9];
                                                r10 = r2 << numDefine3;
                                                r11 = (r9 + r10) | 0;
                                                r11 = r11 >> numDefine2;
                                                r10 = (r7 + r10) | 0;
                                                r12 = heapClassInst.heap32[r11 + 1];
                                                r11 = heapClassInst.heap32[r11];
                                                r10 = r10 >> numDefine2;
                                                r2 = (r2 + 1) | 0;
                                                heapClassInst.heap32[r10] = r11;
                                                heapClassInst.heap32[r10 + 1] = r12;
                                                if (!(r3 != r2)) {
                                                    break repeat33;
                                                }
                                            }
                                            r8 = (r0 + numDefine116) | 0;
                                        }
                                        if (!(r9 == 0)) {
                                            r2 = heapClassInst.heapU8[r0 + numDefine120];
                                            if (!(r2 == 0)) {
                                                r2 = gNumAlignedFree;
                                                r2 = r2 >> numDefine2;
                                                r10 = heapClassInst.heap32[r2];
                                                r10 = (r10 + 1) | 0;
                                                r9 = r9 >> numDefine2;
                                                heapClassInst.heap32[r2] = r10;
                                                r2 = heapClassInst.heap32[r9 + -1];
                                                heapClassInst.heap32[g0] = r2;
                                                free(i7);
                                            }
                                            r2 = r8 >> numDefine2;
                                            heapClassInst.heap32[r2] = 0;
                                        }
                                        r2 = 1;
                                        r8 = r8 >> numDefine2;
                                        heapClassInst.heap8[r0 + numDefine120] = (byte) r2;
                                        heapClassInst.heap32[r8] = r7;
                                        heapClassInst.heap32[r4 + numDefine28] = r1;
                                        if (r3 >= r1) {
                                            break repeat21;
                                        }
                                    }
                                    while (true) {
                                        r2 = r3 << numDefine3;
                                        r7 = heapClassInst.heap32[r4 + numDefine29];
                                        r2 = (r7 + r2) | 0;
                                        r2 = r2 >> numDefine2;
                                        r3 = (r3 + 1) | 0;
                                        heapClassInst.heap32[r2] = 0;
                                        heapClassInst.heap32[r2 + 1] = 0;
                                        if (!(r1 != r3)) {
                                            break repeat21;
                                        }
                                    }
                                }
                            }
                        } while (false);
                        r3 = 0;
                        heapClassInst.heap32[r4 + numDefine27] = r1;
                    } else {
                        r2 = 0;
                        repeat47:
                        while (true) {
                            r3 = r2 << numDefine2;
                            r4 = heapClassInst.heap32[fp + numDefineNeg127];
                            r3 = (r4 + r3) | 0;
                            r3 = r3 >> numDefine2;
                            r3 = heapClassInst.heap32[r3];
                            r4 = r3 >> numDefine2;
                            r4 = heapClassInst.heap32[r4];
                            r4 = r4 >> numDefine2;
                            r4 = heapClassInst.heap32[r4 + numDefine2];
                            r2 = (r2 + 1) | 0;
                            heapClassInst.heap32[g0] = r3;
                            functionTable.get(r4 >> numDefine2).accept(i7);
                            if (r1 == r2) {
                                break repeat47;
                            }
                        }
                        r2 = r0 >> numDefine2;
                        r3 = heapClassInst.heap32[r2 + numDefine27];
                        repeat50:
                        do {
                            if (!(r3 > r1)) {
                                if (!(r3 >= r1)) {
                                    r4 = heapClassInst.heap32[r2 + numDefine28];
                                    if (!(r4 >= r1)) {
                                        if (r1 != 0) {
                                            r4 = gNumAlignedAllocs;
                                            r4 = r4 >> numDefine2;
                                            r7 = heapClassInst.heap32[r4];
                                            r8 = r1 << numDefine3;
                                            r7 = (r7 + 1) | 0;
                                            r8 = r8 | numDefine3;
                                            heapClassInst.heap32[r4] = r7;
                                            r4 = (r8 + numDefine16) | 0;
                                            heapClassInst.heap32[g0] = r4;
                                            mallocNew(i7);
                                            r4 = commonVariable.rg0;
                                            if (r4 != 0) {
                                                r7 = 0;
                                                r8 = (r4 + numDefine4) | 0;
                                                r7 = (r7 - r8) | 0;
                                                r7 = r7 & numDefine15;
                                                r7 = (r4 + r7) | 0;
                                                r8 = (r7 + numDefine4) | 0;
                                                r7 = r7 >> numDefine2;
                                                heapClassInst.heap32[r7] = r4;
                                                r4 = r8;
                                            }
                                        } else {
                                            r4 = 0;
                                        }
                                        r7 = (r0 + numDefine116) | 0;
                                        if (r3 < 1) {
                                            r8 = r7 >> numDefine2;
                                            r9 = heapClassInst.heap32[r8];
                                        } else {
                                            r8 = 0;
                                            repeat63:
                                            while (true) {
                                                r9 = r7 >> numDefine2;
                                                r9 = heapClassInst.heap32[r9];
                                                r10 = r8 << numDefine3;
                                                r11 = (r9 + r10) | 0;
                                                r11 = r11 >> numDefine2;
                                                r10 = (r4 + r10) | 0;
                                                r12 = heapClassInst.heap32[r11 + 1];
                                                r11 = heapClassInst.heap32[r11];
                                                r10 = r10 >> numDefine2;
                                                r8 = (r8 + 1) | 0;
                                                heapClassInst.heap32[r10] = r11;
                                                heapClassInst.heap32[r10 + 1] = r12;
                                                if (!(r3 != r8)) {
                                                    break repeat63;
                                                }
                                            }
                                            r7 = (r0 + numDefine116) | 0;
                                        }
                                        if (!(r9 == 0)) {
                                            r8 = heapClassInst.heapU8[r0 + numDefine120];
                                            if (!(r8 == 0)) {
                                                r8 = gNumAlignedFree;
                                                r8 = r8 >> numDefine2;
                                                r10 = heapClassInst.heap32[r8];
                                                r10 = (r10 + 1) | 0;
                                                r9 = r9 >> numDefine2;
                                                heapClassInst.heap32[r8] = r10;
                                                r8 = heapClassInst.heap32[r9 + -1];
                                                heapClassInst.heap32[g0] = r8;
                                                free(i7);
                                            }
                                            r8 = r7 >> numDefine2;
                                            heapClassInst.heap32[r8] = 0;
                                        }
                                        r8 = 1;
                                        r7 = r7 >> numDefine2;
                                        heapClassInst.heap8[r0 + numDefine120] = (byte) r8;
                                        heapClassInst.heap32[r7] = r4;
                                        heapClassInst.heap32[r2 + numDefine28] = r1;
                                        if (r3 >= r1) {
                                            break repeat50;
                                        }
                                    }
                                    while (true) {
                                        r4 = r3 << numDefine3;
                                        r7 = heapClassInst.heap32[r2 + numDefine29];
                                        r4 = (r7 + r4) | 0;
                                        r4 = r4 >> numDefine2;
                                        r3 = (r3 + 1) | 0;
                                        heapClassInst.heap32[r4] = 0;
                                        heapClassInst.heap32[r4 + 1] = 0;
                                        if (!(r1 != r3)) {
                                            break repeat50;
                                        }
                                    }
                                }
                            }
                        } while (false);
                        heapClassInst.heap32[r2 + numDefine27] = r1;
                        if (r1 > 0) {
                            r4 = 0;
                            r7 = heapClassInst.heap32[fp + numDefineNeg127];
                            r8 = r1;
                            r3 = r4;
                            while (true) {
                                r9 = r7 >> numDefine2;
                                r9 = heapClassInst.heap32[r9];
                                r10 = r9 >> numDefine2;
                                r10 = heapClassInst.heap32[r10];
                                r10 = r10 >> numDefine2;
                                r10 = heapClassInst.heap32[r10 + numDefine4];
                                r11 = heapClassInst.heap32[r2 + numDefine29];
                                r11 = (r11 + r4) | 0;
                                heapClassInst.heap32[g0] = r9;
                                heapClassInst.heap32[g0 + 1] = r11;
                                functionTable.get(r10 >> numDefine2).accept(i7);
                                r9 = r11 >> numDefine2;
                                r9 = heapClassInst.heap32[r9];
                                r8 = (r8 + -1) | 0;
                                r3 = (r9 + r3) | 0;
                                r4 = (r4 + numDefine8) | 0;
                                r7 = (r7 + numDefine4) | 0;
                                if (!(r8 != 0)) {
                                    break repeat19;
                                }
                            }
                        } else {
                            r3 = 0;
                        }
                    }
                } while (false);
                r2 = r0 >> numDefine2;
                r4 = heapClassInst.heap32[r2 + numDefine7];
                repeat82:
                do {
                    if (!(r4 > r3)) {
                        if (!(r4 >= r3)) {
                            r7 = heapClassInst.heap32[r2 + numDefine8];
                            if (!(r7 >= r3)) {
                                if (r3 != 0) {
                                    r7 = gNumAlignedAllocs;
                                    r7 = r7 >> numDefine2;
                                    r8 = heapClassInst.heap32[r7];
                                    r9 = (r3 * numDefine136) | 0;
                                    r8 = (r8 + 1) | 0;
                                    r9 = r9 | numDefine3;
                                    heapClassInst.heap32[r7] = r8;
                                    r7 = (r9 + numDefine16) | 0;
                                    heapClassInst.heap32[g0] = r7;
                                    mallocNew(i7);
                                    r7 = commonVariable.rg0;
                                    if (r7 != 0) {
                                        r8 = 0;
                                        r9 = (r7 + numDefine4) | 0;
                                        r8 = (r8 - r9) | 0;
                                        r8 = r8 & numDefine15;
                                        r8 = (r7 + r8) | 0;
                                        r9 = (r8 + numDefine4) | 0;
                                        r8 = r8 >> numDefine2;
                                        heapClassInst.heap32[r8] = r7;
                                        r7 = r9;
                                    }
                                } else {
                                    r7 = 0;
                                }
                                r8 = (r0 + numDefine36) | 0;
                                if (r4 < 1) {
                                    r9 = r8 >> numDefine2;
                                    r11 = heapClassInst.heap32[r9];
                                } else {
                                    r9 = 0;
                                    r10 = r4;
                                    repeat95:
                                    while (true) {
                                        r11 = r8 >> numDefine2;
                                        r11 = heapClassInst.heap32[r11];
                                        r12 = (r7 + r9) | 0;
                                        r13 = (r11 + r9) | 0;
                                        heapClassInst.heap32[g0] = r12;
                                        heapClassInst.heap32[g0 + 1] = r13;
                                        heapClassInst.heap32[g0 + numDefine2] = numDefine136;
                                        r10 = (r10 + -1) | 0;
                                        r9 = (r9 + numDefine136) | 0;
                                        memcpy(i7);
                                        if (!(r10 != 0)) {
                                            break repeat95;
                                        }
                                    }
                                    r8 = (r0 + numDefine36) | 0;
                                }
                                if (!(r11 == 0)) {
                                    r9 = heapClassInst.heapU8[r0 + numDefine40];
                                    if (!(r9 == 0)) {
                                        r9 = gNumAlignedFree;
                                        r9 = r9 >> numDefine2;
                                        r10 = heapClassInst.heap32[r9];
                                        r10 = (r10 + 1) | 0;
                                        r11 = r11 >> numDefine2;
                                        heapClassInst.heap32[r9] = r10;
                                        r9 = heapClassInst.heap32[r11 + -1];
                                        heapClassInst.heap32[g0] = r9;
                                        free(i7);
                                    }
                                    r9 = r8 >> numDefine2;
                                    heapClassInst.heap32[r9] = 0;
                                }
                                r9 = 1;
                                r8 = r8 >> numDefine2;
                                heapClassInst.heap8[r0 + numDefine40] = (byte) r9;
                                heapClassInst.heap32[r8] = r7;
                                heapClassInst.heap32[r2 + numDefine8] = r3;
                                if (r4 >= r3) {
                                    break repeat82;
                                }
                            }
                            r7 = (r3 - r4) | 0;
                            r4 = (r4 * numDefine136) | 0;
                            while (true) {
                                r8 = heapClassInst.heap32[r2 + numDefine9];
                                r8 = (r8 + r4) | 0;
                                r9 = sp + numDefineNeg448;
                                heapClassInst.heap32[g0] = r8;
                                heapClassInst.heap32[g0 + 1] = r9;
                                heapClassInst.heap32[g0 + numDefine2] = numDefine136;
                                r7 = (r7 + -1) | 0;
                                r4 = (r4 + numDefine136) | 0;
                                memcpy(i7);
                                if (!(r7 != 0)) {
                                    break repeat82;
                                }
                            }
                        }
                    }
                } while (false);
                r4 = 0;
                heapClassInst.heap32[r2 + numDefine7] = r3;
                r7 = r4;
                repeat109:
                while (true) {
                    if (r4 < r1) {
                        r8 = heapClassInst.heap32[r2 + numDefine29];
                        r9 = r4 << numDefine3;
                        r10 = (r8 + r9) | 0;
                        r10 = r10 >> numDefine2;
                        r10 = heapClassInst.heap32[r10];
                        if (r10 != 0) {
                            if (r7 < r3) {
                                r11 = r4 << 1;
                                r12 = r4 << numDefine2;
                                r13 = heapClassInst.heap32[fp + numDefineNeg127];
                                r12 = (r13 + r12) | 0;
                                r12 = r12 >> numDefine2;
                                r13 = heapClassInst.heap32[r12];
                                r14 = r13 >> numDefine2;
                                r15 = heapClassInst.heap32[r2 + numDefine9];
                                r16 = heapClassInst.heap32[r14 + numDefine5];
                                r17 = heapClassInst.heap32[r14 + numDefine6];
                                if (!(r10 < 1)) {
                                    r10 = (r7 * numDefine136) | 0;
                                    r10 = (r15 + r10) | 0;
                                    r18 = 0;
                                    r19 = r18;
                                    repeat117:
                                    while (true) {
                                        r20 = (r19 * numDefine34) | 0;
                                        r21 = numDefine136;
                                        r22 = r18;
                                        repeat119:
                                        while (true) {
                                            r21 = (r21 + -1) | 0;
                                            r23 = (r22 + 1) | 0;
                                            r22 = (r10 + r22) | 0;
                                            r24 = (r19 * numDefine136) | 0;
                                            heapClassInst.heap8[r22 + r24] = (byte) r18;
                                            r22 = r23;
                                            if (!(r21 != 0)) {
                                                break repeat119;
                                            }
                                        }
                                        r21 = r20 << numDefine2;
                                        r22 = r20 << numDefine2;
                                        r21 = (r10 + r21) | 0;
                                        r23 = r20 << numDefine2;
                                        r22 = (r10 + r22) | 0;
                                        r21 = r21 >> numDefine2;
                                        r24 = r20 << numDefine2;
                                        r23 = (r10 + r23) | 0;
                                        r22 = r22 >> numDefine2;
                                        heapClassInst.heap32[r21 + numDefine31] = numDefineNeg88609;
                                        r21 = r20 << numDefine2;
                                        r24 = (r10 + r24) | 0;
                                        r23 = r23 >> numDefine2;
                                        heapClassInst.heap32[r22 + numDefine32] = numDefine95039;
                                        r20 = r20 << numDefine2;
                                        r21 = (r10 + r21) | 0;
                                        r22 = r24 >> numDefine2;
                                        heapClassInst.heap32[r23 + numDefine21] = 0;
                                        r20 = (r10 + r20) | 0;
                                        r23 = r11 << numDefine2;
                                        r21 = r21 >> numDefine2;
                                        heapClassInst.heap32[r22 + numDefine20] = 0;
                                        r22 = (r8 + r23) | 0;
                                        r19 = (r19 + 1) | 0;
                                        r20 = r20 >> numDefine2;
                                        heapClassInst.heap32[r21 + numDefine26] = r16;
                                        r21 = r22 >> numDefine2;
                                        heapClassInst.heap32[r20 + numDefine27] = r17;
                                        r20 = heapClassInst.heap32[r21];
                                        if (!(r20 > r19)) {
                                            break repeat117;
                                        }
                                    }
                                }
                                r10 = r16 >> numDefine2;
                                heapClassInst.heap32[r10 + numDefine126] = 0;
                                heapClassInst.heap32[r10 + numDefine127] = 0;
                                heapClassInst.heap32[r10 + numDefine128] = 0;
                                heapClassInst.heap32[r10 + numDefine129] = 0;
                                heapClassInst.heap32[r10 + numDefine130] = 0;
                                heapClassInst.heap32[r10 + numDefine131] = 0;
                                heapClassInst.heap32[r10 + numDefine132] = 0;
                                heapClassInst.heap32[r10 + numDefine133] = 0;
                                r16 = r17 >> numDefine2;
                                heapClassInst.heap32[r16 + numDefine126] = 0;
                                heapClassInst.heap32[r16 + numDefine127] = 0;
                                heapClassInst.heap32[r16 + numDefine128] = 0;
                                heapClassInst.heap32[r16 + numDefine129] = 0;
                                heapClassInst.heap32[r16 + numDefine130] = 0;
                                heapClassInst.heap32[r16 + numDefine131] = 0;
                                heapClassInst.heap32[r16 + numDefine132] = 0;
                                heapClassInst.heap32[r16 + numDefine133] = 0;
                                f0 = 1;
                                f1 = heapClassInst.heapFloat[r6 + numDefine3];
                                r17 = sp + numDefineNeg504;
                                f1 = f0 / f1;
                                r18 = (r7 * numDefine136) | 0;
                                r15 = (r15 + r18) | 0;
                                r18 = r17 >> numDefine2;
                                heapClassInst.heapFloat[fp + numDefineNeg126] = f1;
                                r19 = (r15 + numDefine16) | 0;
                                heapClassInst.heap32[r18 + 1] = heapClassInst.heap32[r6 + numDefine8];
                                heapClassInst.heap32[r18 + numDefine2] = r19;
                                heapClassInst.heap32[r18 + numDefine3] = r15;
                                r19 = (r15 + numDefine32) | 0;
                                heapClassInst.heap32[r18 + numDefine4] = 0;
                                heapClassInst.heap32[r18 + numDefine5] = r19;
                                r19 = (r15 + numDefine116) | 0;
                                heapClassInst.heap32[r18 + numDefine6] = numDefine34;
                                r20 = r15 >> numDefine2;
                                heapClassInst.heap32[r18 + numDefine7] = r19;
                                heapClassInst.heap32[r20 + numDefine30] = heapClassInst.heap32[r6 + numDefine10];
                                r19 = (r15 + numDefine120) | 0;
                                heapClassInst.heap32[r18 + numDefine13] = heapClassInst.heap32[r6 + 1];
                                r20 = (r15 + numDefine124) | 0;
                                heapClassInst.heap32[r18 + numDefine8] = r19;
                                r19 = (r15 + numDefine128) | 0;
                                heapClassInst.heap32[r18 + numDefine9] = r20;
                                heapClassInst.heap32[r18 + numDefine10] = r19;
                                r19 = heapClassInst.heap32[r6 + numDefine5];
                                heapClassInst.heap32[r18 + numDefine12] = r19;
                                r12 = heapClassInst.heap32[r12];
                                r19 = r12 >> numDefine2;
                                r19 = heapClassInst.heap32[r19];
                                r19 = r19 >> numDefine2;
                                r19 = heapClassInst.heap32[r19 + numDefine5];
                                r11 = r11 << numDefine2;
                                heapClassInst.heap32[g0] = r12;
                                heapClassInst.heap32[g0 + 1] = r17;
                                r8 = (r8 + r11) | 0;
                                r8 = r8 >> numDefine2;
                                functionTable.get(r19 >> numDefine2).accept(i7);
                                r11 = heapClassInst.heap32[r8];
                                repeat123:
                                do {
                                    if (!(r11 < 1)) {
                                        r11 = 0;
                                        while (true) {
                                            r12 = (r11 * numDefine34) | 0;
                                            r12 = r12 << numDefine2;
                                            r12 = (r15 + r12) | 0;
                                            r12 = r12 >> numDefine2;
                                            heapClassInst.heap32[r12 + numDefine28] = r13;
                                            r17 = heapClassInst.heap32[r14 + numDefine5];
                                            r17 = r17 >> numDefine2;
                                            f1 = heapClassInst.heapFloat[r12];
                                            f2 = heapClassInst.heapFloat[r17 + numDefine64];
                                            f3 = heapClassInst.heapFloat[r12 + 1];
                                            f4 = heapClassInst.heapFloat[r17 + numDefine65];
                                            f5 = heapClassInst.heapFloat[r17 + numDefine68];
                                            f6 = heapClassInst.heapFloat[r17 + numDefine69];
                                            f2 = f2 * f1;
                                            f4 = f4 * f3;
                                            f7 = heapClassInst.heapFloat[r12 + numDefine2];
                                            f8 = heapClassInst.heapFloat[r17 + numDefine66];
                                            f9 = heapClassInst.heapFloat[r17 + numDefine72];
                                            f10 = heapClassInst.heapFloat[r17 + numDefine73];
                                            f11 = heapClassInst.heapFloat[r17 + numDefine70];
                                            f5 = f5 * f1;
                                            f6 = f6 * f3;
                                            f2 = f2 + f4;
                                            f4 = f8 * f7;
                                            f8 = heapClassInst.heapFloat[r17 + numDefine74];
                                            f9 = f9 * f1;
                                            f10 = f10 * f3;
                                            f5 = f5 + f6;
                                            f6 = f11 * f7;
                                            f2 = f2 + f4;
                                            f4 = heapClassInst.heapFloat[r17 + numDefine134];
                                            f11 = heapClassInst.heapFloat[r17 + numDefine136];
                                            f12 = heapClassInst.heapFloat[r17 + numDefine135];
                                            f5 = f5 + f6;
                                            f6 = f9 + f10;
                                            f8 = f8 * f7;
                                            f2 = f2 * f4;
                                            f4 = f6 + f8;
                                            f5 = f5 * f12;
                                            heapClassInst.heapFloat[r12 + numDefine12] = f2;
                                            f2 = f4 * f11;
                                            heapClassInst.heapFloat[r12 + numDefine13] = f5;
                                            heapClassInst.heapFloat[r12 + numDefine14] = f2;
                                            heapClassInst.heap32[r12 + numDefine15] = 0;
                                            r17 = heapClassInst.heap32[r14 + numDefine6];
                                            r17 = r17 >> numDefine2;
                                            f2 = heapClassInst.heapFloat[r12 + numDefine8];
                                            f4 = heapClassInst.heapFloat[r17 + numDefine64];
                                            f5 = heapClassInst.heapFloat[r12 + numDefine9];
                                            f6 = heapClassInst.heapFloat[r17 + numDefine65];
                                            f8 = heapClassInst.heapFloat[r17 + numDefine68];
                                            f9 = heapClassInst.heapFloat[r17 + numDefine69];
                                            f4 = f4 * f2;
                                            f6 = f6 * f5;
                                            f10 = heapClassInst.heapFloat[r12 + numDefine10];
                                            f11 = heapClassInst.heapFloat[r17 + numDefine66];
                                            f12 = heapClassInst.heapFloat[r17 + numDefine72];
                                            f13 = heapClassInst.heapFloat[r17 + numDefine73];
                                            f14 = heapClassInst.heapFloat[r17 + numDefine70];
                                            f8 = f8 * f2;
                                            f9 = f9 * f5;
                                            f4 = f4 + f6;
                                            f6 = f11 * f10;
                                            f11 = heapClassInst.heapFloat[r17 + numDefine74];
                                            f12 = f12 * f2;
                                            f13 = f13 * f5;
                                            f8 = f8 + f9;
                                            f9 = f14 * f10;
                                            f4 = f4 + f6;
                                            f6 = heapClassInst.heapFloat[r17 + numDefine134];
                                            f14 = heapClassInst.heapFloat[r17 + numDefine136];
                                            f15 = heapClassInst.heapFloat[r17 + numDefine135];
                                            f8 = f8 + f9;
                                            f9 = f12 + f13;
                                            f11 = f11 * f10;
                                            f4 = f4 * f6;
                                            f6 = f9 + f11;
                                            f8 = f8 * f15;
                                            heapClassInst.heapFloat[r12 + numDefine16] = f4;
                                            f4 = f6 * f14;
                                            heapClassInst.heapFloat[r12 + numDefine17] = f8;
                                            heapClassInst.heapFloat[r12 + numDefine18] = f4;
                                            heapClassInst.heap32[r12 + numDefine19] = 0;
                                            f4 = heapClassInst.heapFloat[r10 + numDefine68];
                                            f6 = heapClassInst.heapFloat[r10 + numDefine69];
                                            f8 = heapClassInst.heapFloat[r10 + numDefine64];
                                            f9 = heapClassInst.heapFloat[r10 + numDefine65];
                                            f11 = heapClassInst.heapFloat[r10 + numDefine72];
                                            f12 = heapClassInst.heapFloat[r10 + numDefine73];
                                            f13 = heapClassInst.heapFloat[r10 + numDefine70];
                                            f14 = heapClassInst.heapFloat[r10 + numDefine66];
                                            f8 = f8 * f1;
                                            f9 = f9 * f3;
                                            f4 = f4 * f1;
                                            f6 = f6 * f3;
                                            f15 = heapClassInst.heapFloat[r10 + numDefine74];
                                            f16 = heapClassInst.heapFloat[r16 + numDefine68];
                                            f17 = heapClassInst.heapFloat[r16 + numDefine69];
                                            f18 = heapClassInst.heapFloat[r16 + numDefine64];
                                            f19 = heapClassInst.heapFloat[r16 + numDefine65];
                                            f8 = f8 + f9;
                                            f9 = f14 * f7;
                                            f4 = f4 + f6;
                                            f6 = f13 * f7;
                                            f11 = f11 * f1;
                                            f12 = f12 * f3;
                                            f13 = heapClassInst.heapFloat[r10 + numDefine84];
                                            f14 = heapClassInst.heapFloat[r12 + numDefine5];
                                            f20 = heapClassInst.heapFloat[r12 + numDefine4];
                                            f21 = heapClassInst.heapFloat[r16 + numDefine84];
                                            f22 = heapClassInst.heapFloat[r12 + numDefine6];
                                            f8 = f8 + f9;
                                            f4 = f4 + f6;
                                            f6 = f20 * f13;
                                            f9 = f14 * f13;
                                            f23 = heapClassInst.heapFloat[r16 + numDefine72];
                                            f24 = heapClassInst.heapFloat[r16 + numDefine73];
                                            f25 = heapClassInst.heapFloat[r16 + numDefine70];
                                            f26 = heapClassInst.heapFloat[r16 + numDefine66];
                                            f18 = f18 * f2;
                                            f19 = f19 * f5;
                                            f16 = f16 * f2;
                                            f17 = f17 * f5;
                                            f11 = f11 + f12;
                                            f12 = f15 * f7;
                                            f15 = heapClassInst.heapFloat[r16 + numDefine74];
                                            f27 = f20 * f21;
                                            f28 = f14 * f21;
                                            f11 = f11 + f12;
                                            f12 = f22 * f13;
                                            f13 = f18 + f19;
                                            f18 = f26 * f10;
                                            f16 = f16 + f17;
                                            f17 = f25 * f10;
                                            f19 = f23 * f2;
                                            f23 = f24 * f5;
                                            f8 = f8 * f1;
                                            f4 = f4 * f3;
                                            f6 = f6 * f20;
                                            f9 = f9 * f14;
                                            f13 = f13 + f18;
                                            f16 = f16 + f17;
                                            f17 = f22 * f21;
                                            f18 = f19 + f23;
                                            f15 = f15 * f10;
                                            f19 = f27 * f20;
                                            f21 = f28 * f14;
                                            f4 = f8 + f4;
                                            f8 = f11 * f7;
                                            f6 = f6 + f9;
                                            f9 = f12 * f22;
                                            f11 = f18 + f15;
                                            f12 = f13 * f2;
                                            f13 = f16 * f5;
                                            f15 = f19 + f21;
                                            f16 = f17 * f22;
                                            f4 = f4 + f8;
                                            f6 = f6 + f9;
                                            f8 = f12 + f13;
                                            f9 = f11 * f10;
                                            f11 = f15 + f16;
                                            f4 = f4 + f6;
                                            f6 = f8 + f9;
                                            f4 = f11 + f4;
                                            f4 = f6 + f4;
                                            f4 = f0 / f4;
                                            heapClassInst.heapFloat[r12 + numDefine23] = f4;
                                            f6 = heapClassInst.heapFloat[r10 + numDefine76];
                                            f8 = heapClassInst.heapFloat[r10 + numDefine77];
                                            f9 = heapClassInst.heapFloat[r10 + numDefine80];
                                            f11 = heapClassInst.heapFloat[r10 + numDefine81];
                                            f12 = heapClassInst.heapFloat[r16 + numDefine80];
                                            f13 = heapClassInst.heapFloat[r16 + numDefine81];
                                            f15 = heapClassInst.heapFloat[r16 + numDefine76];
                                            f16 = heapClassInst.heapFloat[r16 + numDefine77];
                                            f17 = heapClassInst.heapFloat[r10 + numDefine78];
                                            f18 = heapClassInst.heapFloat[r10 + numDefine82];
                                            f19 = heapClassInst.heapFloat[r16 + numDefine82];
                                            f21 = heapClassInst.heapFloat[r16 + numDefine78];
                                            f6 = f20 * f6;
                                            f8 = f14 * f8;
                                            f1 = f1 * f9;
                                            f3 = f3 * f11;
                                            f2 = f2 * f12;
                                            f5 = f5 * f13;
                                            f9 = f20 * f15;
                                            f11 = f14 * f16;
                                            f6 = f6 + f8;
                                            f8 = f22 * f17;
                                            f1 = f1 + f3;
                                            f3 = f7 * f18;
                                            f2 = f2 + f5;
                                            f5 = f10 * f19;
                                            f7 = f9 + f11;
                                            f9 = f22 * f21;
                                            f6 = f6 + f8;
                                            f1 = f1 + f3;
                                            f2 = f2 + f5;
                                            f3 = f7 + f9;
                                            f1 = f6 + f1;
                                            f2 = f2 - f3;
                                            f1 = f1 + f2;
                                            f2 = heapClassInst.heapFloat[r18 + numDefine13];
                                            f3 = 0;
                                            f1 = f2 * f1;
                                            f2 = heapClassInst.heapFloat[r12 + numDefine29];
                                            f1 = f3 - f1;
                                            f2 = f4 * f2;
                                            f1 = f4 * f1;
                                            f1 = f2 + f1;
                                            r11 = (r11 + 1) | 0;
                                            heapClassInst.heapFloat[r12 + numDefine29] = f1;
                                            heapClassInst.heap32[r12 + numDefine21] = 0;
                                            r12 = heapClassInst.heap32[r8];
                                            if (!(r12 > r11)) {
                                                break repeat123;
                                            }
                                        }
                                    }
                                } while (false);
                                r8 = heapClassInst.heap32[r2 + numDefine29];
                                r8 = (r8 + r9) | 0;
                                r8 = r8 >> numDefine2;
                                r8 = heapClassInst.heap32[r8];
                            } else {
                                label = numDefine78;
                                break repeat109;
                            }
                        } else {
                            r8 = 0;
                        }
                        r7 = (r8 + r7) | 0;
                        r4 = (r4 + 1) | 0;
                    } else {
                        label = numDefine90;
                        break repeat109;
                    }
                }
                switch (label) {
                    case numDefine90:
                        r1 = heapClassInst.heap32[fp + numDefineNeg133];
                        repeat132:
                        do {
                            if (!(r1 < 1)) {
                                while (true) {
                                    r1 = heapClassInst.heap32[fp + numDefineNeg132];
                                    r1 = r1 >> numDefine2;
                                    r1 = heapClassInst.heap32[r1];
                                    heapClassInst.heap32[fp + numDefineNeg128] = r1;
                                    r1 = r1 >> numDefine2;
                                    heapClassInst.heap32[fp + numDefineNeg127] = r1;
                                    r3 = heapClassInst.heap32[r1 + numDefine277];
                                    r1 = heapClassInst.heap32[r1 + numDefine278];
                                    r4 = heapClassInst.heapU8[r3 + numDefine232];
                                    r4 = r4 & numDefine2;
                                    if (r4 != 0) {
                                        r4 = r3;
                                    } else {
                                        r4 = 0;
                                    }
                                    r7 = heapClassInst.heapU8[r1 + numDefine232];
                                    r7 = r7 & numDefine2;
                                    if (r7 != 0) {
                                        r7 = r1;
                                    } else {
                                        r7 = 0;
                                    }
                                    if (r4 == 0) {
                                        label = numDefine99;
                                    } else {
                                        r4 = r4 >> numDefine2;
                                        f0 = heapClassInst.heapFloat[r4 + numDefine84];
                                        f1 = 0;
                                        if (f0 != f1) {
                                            label = numDefine101;
                                        } else {
                                            label = numDefine99;
                                        }
                                    }
                                    if (label == numDefine99) {
                                        if (r7 == 0) {
                                            label = numDefine216;
                                        } else {
                                            r4 = r7 >> numDefine2;
                                            f0 = heapClassInst.heapFloat[r4 + numDefine84];
                                            f1 = 0;
                                            if (f0 == f1) {
                                                label = numDefine216;
                                            } else {
                                                label = numDefine101;
                                            }
                                        }
                                    }
                                    if (label == numDefine101) {
                                        r4 = heapClassInst.heap32[fp + numDefineNeg128];
                                        r7 = (r4 + numDefine4) | 0;
                                        heapClassInst.heap32[fp + numDefineNeg129] = r7;
                                        r7 = (r4 + numDefine152) | 0;
                                        heapClassInst.heap32[fp + numDefineNeg130] = r7;
                                        r4 = (r4 + numDefine168) | 0;
                                        heapClassInst.heap32[fp + numDefineNeg131] = r4;
                                        r4 = 0;
                                        r7 = r4;
                                        repeat150:
                                        while (true) {
                                            r8 = heapClassInst.heap32[fp + numDefineNeg127];
                                            r8 = heapClassInst.heap32[r8 + numDefine279];
                                            if (r8 > r7) {
                                                r8 = heapClassInst.heap32[fp + numDefineNeg128];
                                                r8 = (r8 + r4) | 0;
                                                r9 = r8 >> numDefine2;
                                                f0 = heapClassInst.heapFloat[r9 + numDefine21];
                                                r10 = heapClassInst.heap32[fp + numDefineNeg127];
                                                f1 = heapClassInst.heapFloat[r10 + numDefine281];
                                                repeat153:
                                                do {
                                                    if (!(f0 > f1)) {
                                                        r10 = heapClassInst.heap32[fp + numDefineNeg129];
                                                        r10 = (r10 + r4) | 0;
                                                        r11 = heapClassInst.heap32[fp + numDefineNeg131];
                                                        r11 = (r11 + r4) | 0;
                                                        r12 = heapClassInst.heap32[fp + numDefineNeg130];
                                                        r12 = (r12 + r4) | 0;
                                                        r13 = heapClassInst.heap32[r2 + numDefine3];
                                                        r14 = heapClassInst.heap32[r2 + numDefine2];
                                                        if (r13 == r14) {
                                                            r15 = 1;
                                                            r16 = r14 << 1;
                                                            r16 = r14 == 0 ? r15 : r16;
                                                            if (r13 >= r16) {
                                                                label = numDefine104;
                                                            } else {
                                                                if (r16 != 0) {
                                                                    r13 = gNumAlignedAllocs;
                                                                    r13 = r13 >> numDefine2;
                                                                    r17 = heapClassInst.heap32[r13];
                                                                    r18 = (r16 * numDefine136) | 0;
                                                                    r17 = (r17 + 1) | 0;
                                                                    r18 = r18 | numDefine3;
                                                                    heapClassInst.heap32[r13] = r17;
                                                                    r13 = (r18 + numDefine16) | 0;
                                                                    heapClassInst.heap32[g0] = r13;
                                                                    mallocNew(i7);
                                                                    r17 = commonVariable.rg0;
                                                                    if (r17 != 0) {
                                                                        r13 = 0;
                                                                        r18 = (r17 + numDefine4) | 0;
                                                                        r13 = (r13 - r18) | 0;
                                                                        r13 = r13 & numDefine15;
                                                                        r13 = (r17 + r13) | 0;
                                                                        r18 = (r13 + numDefine4) | 0;
                                                                        r13 = r13 >> numDefine2;
                                                                        heapClassInst.heap32[r13] = r17;
                                                                        r17 = r18;
                                                                    }
                                                                } else {
                                                                    r17 = 0;
                                                                }
                                                                if (r14 < 1) {
                                                                    r19 = heapClassInst.heap32[r2 + numDefine4];
                                                                } else {
                                                                    r13 = 0;
                                                                    r18 = r14;
                                                                    repeat166:
                                                                    while (true) {
                                                                        r19 = heapClassInst.heap32[r2 + numDefine4];
                                                                        r20 = (r17 + r13) | 0;
                                                                        r21 = (r19 + r13) | 0;
                                                                        heapClassInst.heap32[g0] = r20;
                                                                        heapClassInst.heap32[g0 + 1] = r21;
                                                                        heapClassInst.heap32[g0 + numDefine2] = numDefine136;
                                                                        r18 = (r18 + -1) | 0;
                                                                        r13 = (r13 + numDefine136) | 0;
                                                                        memcpy(i7);
                                                                        if (!(r18 != 0)) {
                                                                            break repeat166;
                                                                        }
                                                                    }
                                                                }
                                                                if (r19 != 0) {
                                                                    r13 = heapClassInst.heapU8[r0 + numDefine20];
                                                                    if (r13 != 0) {
                                                                        r13 = gNumAlignedFree;
                                                                        r13 = r13 >> numDefine2;
                                                                        r18 = heapClassInst.heap32[r13];
                                                                        r18 = (r18 + 1) | 0;
                                                                        r19 = r19 >> numDefine2;
                                                                        heapClassInst.heap32[r13] = r18;
                                                                        r13 = heapClassInst.heap32[r19 + -1];
                                                                        heapClassInst.heap32[g0] = r13;
                                                                        free(i7);
                                                                        r13 = heapClassInst.heap32[r2 + numDefine2];
                                                                    } else {
                                                                        r13 = r14;
                                                                    }
                                                                    heapClassInst.heap32[r2 + numDefine4] = 0;
                                                                } else {
                                                                    r13 = r14;
                                                                }
                                                                heapClassInst.heap8[r0 + numDefine20] = (byte) r15;
                                                                heapClassInst.heap32[r2 + numDefine4] = r17;
                                                                heapClassInst.heap32[r2 + numDefine3] = r16;
                                                                label = numDefine121;
                                                            }
                                                        } else {
                                                            label = numDefine104;
                                                        }
                                                        if (label == numDefine104) {
                                                            r13 = r14;
                                                        }
                                                        r13 = (r13 + 1) | 0;
                                                        heapClassInst.heap32[r2 + numDefine2] = r13;
                                                        r13 = heapClassInst.heapU8[r3 + numDefine232];
                                                        r15 = heapClassInst.heapU8[r1 + numDefine232];
                                                        r13 = r13 & numDefine2;
                                                        r16 = 0;
                                                        r15 = r15 & numDefine2;
                                                        r13 = r13 == 0 ? r16 : r3;
                                                        r17 = heapClassInst.heap32[r2 + numDefine4];
                                                        r15 = r15 == 0 ? r16 : r1;
                                                        if (r13 == 0) {
                                                            r18 = zgvzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
                                                            r19 = heapClassInst.heapU8[r18];
                                                            if (!(r19 != 0)) {
                                                                r19 = zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
                                                                r20 = r19 >> numDefine2;
                                                                heapClassInst.heap32[r20 + numDefine41] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine42] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine43] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine44] = 0;
                                                                heapClassInst.heap32[r20 + numDefine45] = 0;
                                                                heapClassInst.heap32[r20 + numDefine46] = (int) numDefine44395;
                                                                heapClassInst.heap32[r20 + numDefine47] = 0;
                                                                heapClassInst.heap32[r20 + numDefine48] = 0;
                                                                heapClassInst.heap32[r20 + numDefine49] = 0;
                                                                heapClassInst.heap32[r20 + numDefine50] = 0;
                                                                heapClassInst.heap32[r20 + numDefine51] = 1;
                                                                heapClassInst.heap32[r20 + numDefine52] = -1;
                                                                heapClassInst.heap32[r20 + numDefine53] = -1;
                                                                heapClassInst.heap32[r20 + numDefine54] = 1;
                                                                heapClassInst.heap32[r20 + numDefine55] = 0;
                                                                heapClassInst.heap32[r20 + numDefine56] = (int) numDefine64608;
                                                                heapClassInst.heap32[r20 + numDefine57] = 0;
                                                                heapClassInst.heap32[r20 + numDefine58] = 1;
                                                                heapClassInst.heap32[r20 + numDefine59] = 0;
                                                                heapClassInst.heap32[r20 + numDefine60] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine61] = 0;
                                                                heapClassInst.heap32[r20 + numDefine62] = 0;
                                                                heapClassInst.heap32[r20 + numDefine63] = 0;
                                                                heapClassInst.heap32[r20 + 1] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine2] = 0;
                                                                heapClassInst.heap32[r20 + numDefine3] = 0;
                                                                heapClassInst.heap32[r20 + numDefine4] = 0;
                                                                heapClassInst.heap32[r20 + numDefine5] = 0;
                                                                heapClassInst.heap32[r20 + numDefine6] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine7] = 0;
                                                                heapClassInst.heap32[r20 + numDefine8] = 0;
                                                                heapClassInst.heap32[r20 + numDefine9] = 0;
                                                                heapClassInst.heap32[r20 + numDefine10] = 0;
                                                                heapClassInst.heap32[r20 + numDefine11] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine12] = 0;
                                                                heapClassInst.heap32[r20 + numDefine13] = 0;
                                                                heapClassInst.heap32[r20 + numDefine14] = 0;
                                                                r21 = ztv11btRigidBody;
                                                                heapClassInst.heap32[r20 + numDefine15] = 0;
                                                                r21 = (r21 + numDefine8) | 0;
                                                                heapClassInst.heap32[r20 + numDefine16] = 0;
                                                                r22 = 1;
                                                                heapClassInst.heap32[r20] = r21;
                                                                heapClassInst.heap8[r19 + numDefine492] = (byte) r22;
                                                                heapClassInst.heap32[r20 + numDefine122] = 0;
                                                                heapClassInst.heap32[r20 + numDefine120] = 0;
                                                                r21 = sp + numDefineNeg280;
                                                                heapClassInst.heap32[r20 + numDefine121] = 0;
                                                                r20 = r21 >> numDefine2;
                                                                heapClassInst.heap32[fp + numDefineNeg70] = 0;
                                                                heapClassInst.heap32[r20 + 1] = 0;
                                                                heapClassInst.heap32[r20 + numDefine18] = 0;
                                                                heapClassInst.heap32[r20 + numDefine19] = 0;
                                                                heapClassInst.heap32[r20 + numDefine20] = 0;
                                                                heapClassInst.heap32[r20 + numDefine21] = 0;
                                                                heapClassInst.heap32[r20 + numDefine22] = 0;
                                                                heapClassInst.heap32[r20 + numDefine23] = 0;
                                                                heapClassInst.heap32[r20 + numDefine24] = 0;
                                                                heapClassInst.heap32[r20 + numDefine25] = (int) numDefine64608;
                                                                heapClassInst.heap32[r20 + numDefine26] = 0;
                                                                heapClassInst.heap32[r20 + numDefine27] = (int) numDefine97773;
                                                                heapClassInst.heap32[r20 + numDefine28] = (int) numDefine53216;
                                                                heapClassInst.heap8[sp + numDefineNeg164] = (byte) r16;
                                                                heapClassInst.heap32[r20 + numDefine30] = (int) numDefine93162;
                                                                heapClassInst.heap32[r20 + numDefine31] = (int) numDefine81770;
                                                                heapClassInst.heap32[r20 + numDefine32] = (int) numDefine81770;
                                                                heapClassInst.heap32[r20 + numDefine33] = (int) numDefine81770;
                                                                heapClassInst.heap32[r20 + numDefine2] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine3] = 0;
                                                                heapClassInst.heap32[r20 + numDefine4] = 0;
                                                                heapClassInst.heap32[r20 + numDefine5] = 0;
                                                                heapClassInst.heap32[r20 + numDefine6] = 0;
                                                                heapClassInst.heap32[r20 + numDefine7] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine8] = 0;
                                                                heapClassInst.heap32[r20 + numDefine9] = 0;
                                                                heapClassInst.heap32[r20 + numDefine10] = 0;
                                                                heapClassInst.heap32[r20 + numDefine11] = 0;
                                                                heapClassInst.heap32[r20 + numDefine12] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine13] = 0;
                                                                heapClassInst.heap32[r20 + numDefine14] = 0;
                                                                heapClassInst.heap32[r20 + numDefine15] = 0;
                                                                heapClassInst.heap32[r20 + numDefine16] = 0;
                                                                heapClassInst.heap32[r20 + numDefine17] = 0;
                                                                heapClassInst.heap32[g0] = r19;
                                                                heapClassInst.heap32[g0 + 1] = r21;
                                                                zn11btRigidBody14setupRigidBodyERKNS27btRigidBodyConstructionInfoE(i7);
                                                                heapClassInst.heap8[r18] = (byte) r22;
                                                            }
                                                            r18 = zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
                                                            r19 = r18 >> numDefine2;
                                                            r20 = heapClassInst.heap32[r19 + numDefine51];
                                                            r20 = r20 | 1;
                                                            heapClassInst.heap32[r19 + numDefine51] = r20;
                                                            heapClassInst.heap32[r19 + numDefine84] = 0;
                                                            f0 = 0;
                                                            f1 = heapClassInst.heapFloat[r19 + numDefine95];
                                                            f2 = heapClassInst.heapFloat[r19 + numDefine94];
                                                            f3 = heapClassInst.heapFloat[r19 + numDefine93];
                                                            f3 = f3 * f0;
                                                            f2 = f2 * f0;
                                                            heapClassInst.heapFloat[r19 + numDefine89] = f3;
                                                            f1 = f1 * f0;
                                                            heapClassInst.heapFloat[r19 + numDefine90] = f2;
                                                            heapClassInst.heapFloat[r19 + numDefine91] = f1;
                                                            heapClassInst.heap32[r19 + numDefine92] = 0;
                                                            heapClassInst.heap32[r19 + numDefine97] = 0;
                                                            heapClassInst.heap32[r19 + numDefine98] = 0;
                                                            heapClassInst.heap32[r19 + numDefine99] = 0;
                                                            heapClassInst.heap32[r19 + numDefine100] = 0;
                                                            f1 = heapClassInst.heapFloat[r19 + numDefine87];
                                                            f2 = heapClassInst.heapFloat[r19 + numDefine86];
                                                            f3 = heapClassInst.heapFloat[r19 + numDefine85];
                                                            f3 = f3 * f0;
                                                            f2 = f2 * f0;
                                                            heapClassInst.heapFloat[r19 + numDefine138] = f3;
                                                            f0 = f1 * f0;
                                                            heapClassInst.heapFloat[r19 + numDefine139] = f2;
                                                            heapClassInst.heapFloat[r19 + numDefine140] = f0;
                                                            heapClassInst.heap32[r19 + numDefine141] = 0;
                                                        } else {
                                                            r18 = r13;
                                                        }
                                                        r19 = (r14 * numDefine136) | 0;
                                                        r17 = (r17 + r19) | 0;
                                                        r17 = r17 >> numDefine2;
                                                        heapClassInst.heap32[r17 + numDefine26] = r18;
                                                        if (r15 == 0) {
                                                            r18 = zgvzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
                                                            r19 = heapClassInst.heapU8[r18];
                                                            if (!(r19 != 0)) {
                                                                r19 = zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
                                                                r20 = r19 >> numDefine2;
                                                                heapClassInst.heap32[r20 + numDefine41] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine42] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine43] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine44] = 0;
                                                                heapClassInst.heap32[r20 + numDefine45] = 0;
                                                                heapClassInst.heap32[r20 + numDefine46] = (int) numDefine44395;
                                                                heapClassInst.heap32[r20 + numDefine47] = 0;
                                                                heapClassInst.heap32[r20 + numDefine48] = 0;
                                                                heapClassInst.heap32[r20 + numDefine49] = 0;
                                                                heapClassInst.heap32[r20 + numDefine50] = 0;
                                                                heapClassInst.heap32[r20 + numDefine51] = 1;
                                                                heapClassInst.heap32[r20 + numDefine52] = -1;
                                                                heapClassInst.heap32[r20 + numDefine53] = -1;
                                                                heapClassInst.heap32[r20 + numDefine54] = 1;
                                                                heapClassInst.heap32[r20 + numDefine55] = 0;
                                                                heapClassInst.heap32[r20 + numDefine56] = (int) numDefine64608;
                                                                heapClassInst.heap32[r20 + numDefine57] = 0;
                                                                heapClassInst.heap32[r20 + numDefine58] = 1;
                                                                heapClassInst.heap32[r20 + numDefine59] = 0;
                                                                heapClassInst.heap32[r20 + numDefine60] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine61] = 0;
                                                                heapClassInst.heap32[r20 + numDefine62] = 0;
                                                                heapClassInst.heap32[r20 + numDefine63] = 0;
                                                                heapClassInst.heap32[r20 + 1] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine2] = 0;
                                                                heapClassInst.heap32[r20 + numDefine3] = 0;
                                                                heapClassInst.heap32[r20 + numDefine4] = 0;
                                                                heapClassInst.heap32[r20 + numDefine5] = 0;
                                                                heapClassInst.heap32[r20 + numDefine6] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine7] = 0;
                                                                heapClassInst.heap32[r20 + numDefine8] = 0;
                                                                heapClassInst.heap32[r20 + numDefine9] = 0;
                                                                heapClassInst.heap32[r20 + numDefine10] = 0;
                                                                heapClassInst.heap32[r20 + numDefine11] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine12] = 0;
                                                                heapClassInst.heap32[r20 + numDefine13] = 0;
                                                                heapClassInst.heap32[r20 + numDefine14] = 0;
                                                                r21 = ztv11btRigidBody;
                                                                heapClassInst.heap32[r20 + numDefine15] = 0;
                                                                r21 = (r21 + numDefine8) | 0;
                                                                heapClassInst.heap32[r20 + numDefine16] = 0;
                                                                r22 = 1;
                                                                heapClassInst.heap32[r20] = r21;
                                                                heapClassInst.heap8[r19 + numDefine492] = (byte) r22;
                                                                heapClassInst.heap32[r20 + numDefine122] = 0;
                                                                heapClassInst.heap32[r20 + numDefine120] = 0;
                                                                r21 = sp + numDefineNeg144;
                                                                heapClassInst.heap32[r20 + numDefine121] = 0;
                                                                r20 = r21 >> numDefine2;
                                                                heapClassInst.heap32[fp + numDefineNeg36] = 0;
                                                                heapClassInst.heap32[r20 + 1] = 0;
                                                                heapClassInst.heap32[r20 + numDefine18] = 0;
                                                                heapClassInst.heap32[r20 + numDefine19] = 0;
                                                                heapClassInst.heap32[r20 + numDefine20] = 0;
                                                                heapClassInst.heap32[r20 + numDefine21] = 0;
                                                                heapClassInst.heap32[r20 + numDefine22] = 0;
                                                                heapClassInst.heap32[r20 + numDefine23] = 0;
                                                                heapClassInst.heap32[r20 + numDefine24] = 0;
                                                                heapClassInst.heap32[r20 + numDefine25] = (int) numDefine64608;
                                                                heapClassInst.heap32[r20 + numDefine26] = 0;
                                                                heapClassInst.heap32[r20 + numDefine27] = (int) numDefine97773;
                                                                heapClassInst.heap32[r20 + numDefine28] = (int) numDefine53216;
                                                                heapClassInst.heap8[sp + numDefineNeg28] = (byte) r16;
                                                                heapClassInst.heap32[r20 + numDefine30] = (int) numDefine93162;
                                                                heapClassInst.heap32[r20 + numDefine31] = (int) numDefine81770;
                                                                heapClassInst.heap32[r20 + numDefine32] = (int) numDefine81770;
                                                                heapClassInst.heap32[r20 + numDefine33] = (int) numDefine81770;
                                                                heapClassInst.heap32[r20 + numDefine2] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine3] = 0;
                                                                heapClassInst.heap32[r20 + numDefine4] = 0;
                                                                heapClassInst.heap32[r20 + numDefine5] = 0;
                                                                heapClassInst.heap32[r20 + numDefine6] = 0;
                                                                heapClassInst.heap32[r20 + numDefine7] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine8] = 0;
                                                                heapClassInst.heap32[r20 + numDefine9] = 0;
                                                                heapClassInst.heap32[r20 + numDefine10] = 0;
                                                                heapClassInst.heap32[r20 + numDefine11] = 0;
                                                                heapClassInst.heap32[r20 + numDefine12] = (int) numDefine53216;
                                                                heapClassInst.heap32[r20 + numDefine13] = 0;
                                                                heapClassInst.heap32[r20 + numDefine14] = 0;
                                                                heapClassInst.heap32[r20 + numDefine15] = 0;
                                                                heapClassInst.heap32[r20 + numDefine16] = 0;
                                                                heapClassInst.heap32[r20 + numDefine17] = 0;
                                                                heapClassInst.heap32[g0] = r19;
                                                                heapClassInst.heap32[g0 + 1] = r21;
                                                                zn11btRigidBody14setupRigidBodyERKNS27btRigidBodyConstructionInfoE(i7);
                                                                heapClassInst.heap8[r18] = (byte) r22;
                                                            }
                                                            r18 = zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
                                                            r19 = r18 >> numDefine2;
                                                            r20 = heapClassInst.heap32[r19 + numDefine51];
                                                            r20 = r20 | 1;
                                                            heapClassInst.heap32[r19 + numDefine51] = r20;
                                                            heapClassInst.heap32[r19 + numDefine84] = 0;
                                                            f0 = 0;
                                                            f1 = heapClassInst.heapFloat[r19 + numDefine95];
                                                            f2 = heapClassInst.heapFloat[r19 + numDefine94];
                                                            f3 = heapClassInst.heapFloat[r19 + numDefine93];
                                                            f3 = f3 * f0;
                                                            f2 = f2 * f0;
                                                            heapClassInst.heapFloat[r19 + numDefine89] = f3;
                                                            f1 = f1 * f0;
                                                            heapClassInst.heapFloat[r19 + numDefine90] = f2;
                                                            heapClassInst.heapFloat[r19 + numDefine91] = f1;
                                                            heapClassInst.heap32[r19 + numDefine92] = 0;
                                                            heapClassInst.heap32[r19 + numDefine97] = 0;
                                                            heapClassInst.heap32[r19 + numDefine98] = 0;
                                                            heapClassInst.heap32[r19 + numDefine99] = 0;
                                                            heapClassInst.heap32[r19 + numDefine100] = 0;
                                                            f1 = heapClassInst.heapFloat[r19 + numDefine87];
                                                            f2 = heapClassInst.heapFloat[r19 + numDefine86];
                                                            f3 = heapClassInst.heapFloat[r19 + numDefine85];
                                                            f3 = f3 * f0;
                                                            f2 = f2 * f0;
                                                            heapClassInst.heapFloat[r19 + numDefine138] = f3;
                                                            f0 = f1 * f0;
                                                            heapClassInst.heapFloat[r19 + numDefine139] = f2;
                                                            heapClassInst.heapFloat[r19 + numDefine140] = f0;
                                                            heapClassInst.heap32[r19 + numDefine141] = 0;
                                                        } else {
                                                            r18 = r15;
                                                        }
                                                        heapClassInst.heap32[r17 + numDefine27] = r18;
                                                        r18 = r1 >> numDefine2;
                                                        heapClassInst.heap32[r17 + numDefine28] = r10;
                                                        r19 = r3 >> numDefine2;
                                                        r20 = heapClassInst.heap32[r19 + numDefine58];
                                                        r21 = heapClassInst.heap32[r18 + numDefine58];
                                                        f0 = heapClassInst.heapFloat[r9 + numDefine15];
                                                        f1 = heapClassInst.heapFloat[r19 + numDefine15];
                                                        f2 = heapClassInst.heapFloat[r9 + numDefine14];
                                                        f3 = heapClassInst.heapFloat[r19 + numDefine14];
                                                        f4 = heapClassInst.heapFloat[r9 + numDefine13];
                                                        f5 = heapClassInst.heapFloat[r19 + numDefine13];
                                                        r19 = sp + numDefineNeg296;
                                                        f4 = f4 - f5;
                                                        f2 = f2 - f3;
                                                        r22 = r19 >> numDefine2;
                                                        heapClassInst.heapFloat[fp + numDefineNeg74] = f4;
                                                        f0 = f0 - f1;
                                                        heapClassInst.heapFloat[r22 + 1] = f2;
                                                        heapClassInst.heapFloat[r22 + numDefine2] = f0;
                                                        heapClassInst.heap32[r22 + numDefine3] = 0;
                                                        f1 = heapClassInst.heapFloat[r9 + numDefine11];
                                                        f3 = heapClassInst.heapFloat[r18 + numDefine15];
                                                        f5 = heapClassInst.heapFloat[r9 + numDefine10];
                                                        f6 = heapClassInst.heapFloat[r18 + numDefine14];
                                                        f7 = heapClassInst.heapFloat[r9 + numDefine9];
                                                        f8 = heapClassInst.heapFloat[r18 + numDefine13];
                                                        r18 = sp + numDefineNeg312;
                                                        f7 = f7 - f8;
                                                        f5 = f5 - f6;
                                                        r22 = r18 >> numDefine2;
                                                        heapClassInst.heapFloat[fp + numDefineNeg78] = f7;
                                                        f1 = f1 - f3;
                                                        heapClassInst.heapFloat[r22 + 1] = f5;
                                                        heapClassInst.heapFloat[r22 + numDefine2] = f1;
                                                        r23 = r8 >> numDefine2;
                                                        heapClassInst.heap32[r22 + numDefine3] = 0;
                                                        r22 = r8 >> numDefine2;
                                                        r24 = r8 >> numDefine2;
                                                        r20 = r20 & numDefine2;
                                                        r21 = r21 & numDefine2;
                                                        r20 = r20 == 0 ? r16 : r3;
                                                        r16 = r21 == 0 ? r16 : r1;
                                                        if (r20 == 0) {
                                                            heapClassInst.heap32[r17 + numDefine12] = 0;
                                                            heapClassInst.heap32[r17 + numDefine13] = 0;
                                                            f3 = 0;
                                                            heapClassInst.heap32[r17 + numDefine14] = 0;
                                                            heapClassInst.heap32[r17 + numDefine15] = 0;
                                                            f6 = f3;
                                                            f8 = f3;
                                                        } else {
                                                            f3 = heapClassInst.heapFloat[r23 + numDefine17];
                                                            f6 = heapClassInst.heapFloat[r22 + numDefine19];
                                                            f8 = heapClassInst.heapFloat[r24 + numDefine18];
                                                            f9 = f4 * f8;
                                                            f10 = f2 * f3;
                                                            f3 = f0 * f3;
                                                            f11 = f4 * f6;
                                                            f6 = f2 * f6;
                                                            f8 = f0 * f8;
                                                            f9 = f9 - f10;
                                                            f3 = f3 - f11;
                                                            f6 = f6 - f8;
                                                            r21 = r20 >> numDefine2;
                                                            f8 = heapClassInst.heapFloat[r21 + numDefine64];
                                                            f10 = heapClassInst.heapFloat[r21 + numDefine65];
                                                            f11 = heapClassInst.heapFloat[r21 + numDefine68];
                                                            f12 = heapClassInst.heapFloat[r21 + numDefine69];
                                                            f8 = f8 * f6;
                                                            f10 = f10 * f3;
                                                            f13 = heapClassInst.heapFloat[r21 + numDefine66];
                                                            f14 = heapClassInst.heapFloat[r21 + numDefine72];
                                                            f15 = heapClassInst.heapFloat[r21 + numDefine73];
                                                            f16 = heapClassInst.heapFloat[r21 + numDefine70];
                                                            f11 = f11 * f6;
                                                            f12 = f12 * f3;
                                                            f8 = f8 + f10;
                                                            f10 = f13 * f9;
                                                            f13 = heapClassInst.heapFloat[r21 + numDefine74];
                                                            f6 = f14 * f6;
                                                            f3 = f15 * f3;
                                                            f11 = f11 + f12;
                                                            f12 = f16 * f9;
                                                            f8 = f8 + f10;
                                                            f10 = heapClassInst.heapFloat[r21 + numDefine134];
                                                            f14 = heapClassInst.heapFloat[r21 + numDefine136];
                                                            f15 = heapClassInst.heapFloat[r21 + numDefine135];
                                                            f11 = f11 + f12;
                                                            f8 = f8 * f10;
                                                            f3 = f6 + f3;
                                                            f6 = f13 * f9;
                                                            f3 = f3 + f6;
                                                            f6 = f11 * f15;
                                                            heapClassInst.heapFloat[r17 + numDefine12] = f8;
                                                            f3 = f3 * f14;
                                                            heapClassInst.heapFloat[r17 + numDefine13] = f6;
                                                            heapClassInst.heapFloat[r17 + numDefine14] = f3;
                                                            heapClassInst.heap32[r17 + numDefine15] = 0;
                                                        }
                                                        if (r16 == 0) {
                                                            heapClassInst.heap32[r17 + numDefine16] = 0;
                                                            heapClassInst.heap32[r17 + numDefine17] = 0;
                                                            f10 = 0;
                                                            heapClassInst.heap32[r17 + numDefine18] = 0;
                                                            heapClassInst.heap32[r17 + numDefine19] = 0;
                                                            f11 = f10;
                                                            f9 = f10;
                                                        } else {
                                                            f9 = heapClassInst.heapFloat[r24 + numDefine18];
                                                            f10 = heapClassInst.heapFloat[r23 + numDefine17];
                                                            f11 = heapClassInst.heapFloat[r22 + numDefine19];
                                                            f12 = f5 * f11;
                                                            f13 = f1 * f9;
                                                            r21 = r16 >> numDefine2;
                                                            f12 = f12 - f13;
                                                            f13 = f1 * f10;
                                                            f11 = f7 * f11;
                                                            f12 = -f12;
                                                            f14 = heapClassInst.heapFloat[r21 + numDefine64];
                                                            f11 = f13 - f11;
                                                            f13 = heapClassInst.heapFloat[r21 + numDefine65];
                                                            f9 = f7 * f9;
                                                            f10 = f5 * f10;
                                                            f15 = heapClassInst.heapFloat[r21 + numDefine68];
                                                            f16 = heapClassInst.heapFloat[r21 + numDefine69];
                                                            f14 = f14 * f12;
                                                            f13 = f13 * f11;
                                                            f9 = f9 - f10;
                                                            f10 = heapClassInst.heapFloat[r21 + numDefine66];
                                                            f17 = heapClassInst.heapFloat[r21 + numDefine72];
                                                            f18 = heapClassInst.heapFloat[r21 + numDefine73];
                                                            f19 = heapClassInst.heapFloat[r21 + numDefine70];
                                                            f15 = f15 * f12;
                                                            f16 = f16 * f11;
                                                            f13 = f14 - f13;
                                                            f10 = f10 * f9;
                                                            f14 = heapClassInst.heapFloat[r21 + numDefine74];
                                                            f12 = f17 * f12;
                                                            f11 = f18 * f11;
                                                            f15 = f15 - f16;
                                                            f16 = f19 * f9;
                                                            f10 = f13 - f10;
                                                            f13 = heapClassInst.heapFloat[r21 + numDefine134];
                                                            f17 = heapClassInst.heapFloat[r21 + numDefine136];
                                                            f18 = heapClassInst.heapFloat[r21 + numDefine135];
                                                            f15 = f15 - f16;
                                                            f10 = f10 * f13;
                                                            f11 = f12 - f11;
                                                            f9 = f14 * f9;
                                                            f9 = f11 - f9;
                                                            f11 = f15 * f18;
                                                            heapClassInst.heapFloat[r17 + numDefine16] = f10;
                                                            f9 = f9 * f17;
                                                            heapClassInst.heapFloat[r17 + numDefine17] = f11;
                                                            heapClassInst.heapFloat[r17 + numDefine18] = f9;
                                                            heapClassInst.heap32[r17 + numDefine19] = 0;
                                                        }
                                                        if (r20 != 0) {
                                                            f12 = f6 * f0;
                                                            f13 = f3 * f2;
                                                            f3 = f3 * f4;
                                                            f14 = f8 * f0;
                                                            f15 = heapClassInst.heapFloat[r23 + numDefine17];
                                                            f12 = f12 - f13;
                                                            f13 = heapClassInst.heapFloat[r24 + numDefine18];
                                                            f3 = f3 - f14;
                                                            f8 = f8 * f2;
                                                            f6 = f6 * f4;
                                                            f12 = f15 * f12;
                                                            f3 = f13 * f3;
                                                            f13 = heapClassInst.heapFloat[r22 + numDefine19];
                                                            f6 = f8 - f6;
                                                            r21 = r20 >> numDefine2;
                                                            f3 = f12 + f3;
                                                            f6 = f13 * f6;
                                                            f8 = heapClassInst.heapFloat[r21 + numDefine84];
                                                            f3 = f3 + f6;
                                                            f3 = f8 + f3;
                                                        } else {
                                                            f3 = 0;
                                                        }
                                                        if (r16 != 0) {
                                                            f6 = f5 * f9;
                                                            f8 = f1 * f11;
                                                            f12 = f1 * f10;
                                                            f9 = f7 * f9;
                                                            f13 = heapClassInst.heapFloat[r23 + numDefine17];
                                                            f6 = f6 - f8;
                                                            f8 = heapClassInst.heapFloat[r24 + numDefine18];
                                                            f9 = f12 - f9;
                                                            f11 = f7 * f11;
                                                            f10 = f5 * f10;
                                                            f6 = f13 * f6;
                                                            f9 = f8 * f9;
                                                            f8 = heapClassInst.heapFloat[r22 + numDefine19];
                                                            f10 = f11 - f10;
                                                            r21 = r16 >> numDefine2;
                                                            f9 = f6 + f9;
                                                            f6 = f8 * f10;
                                                            f8 = heapClassInst.heapFloat[r21 + numDefine84];
                                                            f9 = f9 + f6;
                                                            f9 = f8 + f9;
                                                        } else {
                                                            f9 = 0;
                                                        }
                                                        f6 = 1;
                                                        f3 = f3 + f9;
                                                        f3 = f6 / f3;
                                                        heapClassInst.heapFloat[r17 + numDefine23] = f3;
                                                        f3 = heapClassInst.heapFloat[r23 + numDefine17];
                                                        heapClassInst.heapFloat[r17 + numDefine4] = f3;
                                                        f8 = heapClassInst.heapFloat[r24 + numDefine18];
                                                        heapClassInst.heapFloat[r17 + numDefine5] = f8;
                                                        f9 = heapClassInst.heapFloat[r22 + numDefine19];
                                                        heapClassInst.heapFloat[r17 + numDefine6] = f9;
                                                        heapClassInst.heap32[r17 + numDefine7] = heapClassInst.heap32[r9 + numDefine20];
                                                        f10 = heapClassInst.heapFloat[r22 + numDefine19];
                                                        f11 = heapClassInst.heapFloat[r24 + numDefine18];
                                                        f12 = heapClassInst.heapFloat[r23 + numDefine17];
                                                        f13 = f2 * f10;
                                                        f14 = f0 * f11;
                                                        f15 = f0 * f12;
                                                        f10 = f4 * f10;
                                                        f13 = f13 - f14;
                                                        f11 = f4 * f11;
                                                        f12 = f2 * f12;
                                                        f10 = f15 - f10;
                                                        heapClassInst.heapFloat[r17] = f13;
                                                        f11 = f11 - f12;
                                                        heapClassInst.heapFloat[r17 + 1] = f10;
                                                        heapClassInst.heapFloat[r17 + numDefine2] = f11;
                                                        heapClassInst.heap32[r17 + numDefine3] = 0;
                                                        f10 = heapClassInst.heapFloat[r24 + numDefine18];
                                                        f11 = heapClassInst.heapFloat[r22 + numDefine19];
                                                        f12 = heapClassInst.heapFloat[r23 + numDefine17];
                                                        f13 = f1 * f10;
                                                        f14 = f5 * f11;
                                                        f11 = f7 * f11;
                                                        f15 = f1 * f12;
                                                        f13 = f13 - f14;
                                                        f12 = f5 * f12;
                                                        f10 = f7 * f10;
                                                        f11 = f11 - f15;
                                                        heapClassInst.heapFloat[r17 + numDefine8] = f13;
                                                        f10 = f12 - f10;
                                                        heapClassInst.heapFloat[r17 + numDefine9] = f11;
                                                        heapClassInst.heapFloat[r17 + numDefine10] = f10;
                                                        heapClassInst.heap32[r17 + numDefine11] = 0;
                                                        if (r20 != 0) {
                                                            r21 = r20 >> numDefine2;
                                                            f10 = heapClassInst.heapFloat[r21 + numDefine81];
                                                            f11 = heapClassInst.heapFloat[r21 + numDefine80];
                                                            f12 = heapClassInst.heapFloat[r21 + numDefine82];
                                                            f13 = f11 * f2;
                                                            f14 = f10 * f4;
                                                            f4 = f12 * f4;
                                                            f11 = f11 * f0;
                                                            f0 = f10 * f0;
                                                            f2 = f12 * f2;
                                                            f10 = heapClassInst.heapFloat[r21 + numDefine78];
                                                            f12 = f13 - f14;
                                                            f13 = heapClassInst.heapFloat[r21 + numDefine77];
                                                            f11 = f4 - f11;
                                                            f14 = heapClassInst.heapFloat[r21 + numDefine76];
                                                            f0 = f0 - f2;
                                                            f4 = f10 + f12;
                                                            f2 = f13 + f11;
                                                            f0 = f14 + f0;
                                                        } else {
                                                            f0 = 0;
                                                            f2 = f0;
                                                            f4 = f0;
                                                        }
                                                        if (r16 != 0) {
                                                            r21 = r16 >> numDefine2;
                                                            f10 = heapClassInst.heapFloat[r21 + numDefine81];
                                                            f11 = heapClassInst.heapFloat[r21 + numDefine80];
                                                            f12 = heapClassInst.heapFloat[r21 + numDefine82];
                                                            f13 = f11 * f5;
                                                            f14 = f10 * f7;
                                                            f7 = f12 * f7;
                                                            f11 = f11 * f1;
                                                            f1 = f10 * f1;
                                                            f5 = f12 * f5;
                                                            f10 = heapClassInst.heapFloat[r21 + numDefine78];
                                                            f12 = f13 - f14;
                                                            f13 = heapClassInst.heapFloat[r21 + numDefine77];
                                                            f11 = f7 - f11;
                                                            f14 = heapClassInst.heapFloat[r21 + numDefine76];
                                                            f1 = f1 - f5;
                                                            f7 = f10 + f12;
                                                            f5 = f13 + f11;
                                                            f1 = f14 + f1;
                                                        } else {
                                                            f1 = 0;
                                                            f5 = f1;
                                                            f7 = f1;
                                                        }
                                                        f0 = f0 - f1;
                                                        f1 = f2 - f5;
                                                        f2 = heapClassInst.heapFloat[r23 + numDefine17];
                                                        f5 = heapClassInst.heapFloat[r24 + numDefine18];
                                                        f4 = f4 - f7;
                                                        f7 = heapClassInst.heapFloat[r22 + numDefine19];
                                                        f2 = f2 * f0;
                                                        f5 = f5 * f1;
                                                        f2 = f2 + f5;
                                                        f5 = f7 * f4;
                                                        f7 = heapClassInst.heapFloat[r9 + numDefine21];
                                                        f10 = heapClassInst.heapFloat[r6 + numDefine13];
                                                        f2 = f2 + f5;
                                                        f5 = f7 + f10;
                                                        heapClassInst.heap32[r17 + numDefine22] = heapClassInst.heap32[r9 + numDefine22];
                                                        r21 = heapClassInst.heap32[r9 + numDefine37];
                                                        r25 = heapClassInst.heap32[r6 + numDefine16];
                                                        if (r21 > r25) {
                                                            label = numDefine151;
                                                        } else {
                                                            f7 = heapClassInst.heapFloat[r9 + numDefine23];
                                                            f10 = -f2;
                                                            f7 = f7 * f10;
                                                            f10 = 0;
                                                            if (f7 <= f10) {
                                                                label = numDefine151;
                                                            } else {
                                                                label = numDefine152;
                                                            }
                                                        }
                                                        if (label == numDefine151) {
                                                            f7 = 0;
                                                        }
                                                        r21 = heapClassInst.heapU8[r5 + numDefine60];
                                                        r21 = r21 & numDefine4;
                                                        if (r21 == 0) {
                                                            heapClassInst.heap32[r17 + numDefine21] = 0;
                                                        } else {
                                                            f10 = heapClassInst.heapFloat[r9 + numDefine29];
                                                            f11 = heapClassInst.heapFloat[r6 + numDefine14];
                                                            f10 = f10 * f11;
                                                            heapClassInst.heapFloat[r17 + numDefine21] = f10;
                                                            if (!(r20 == 0)) {
                                                                r21 = r20 >> numDefine2;
                                                                f11 = heapClassInst.heapFloat[r21 + numDefine84];
                                                                f12 = 0;
                                                                if (!(f11 == f12)) {
                                                                    f3 = f3 * f11;
                                                                    f12 = heapClassInst.heapFloat[r21 + numDefine85];
                                                                    f3 = f3 * f12;
                                                                    f3 = f3 * f10;
                                                                    f12 = heapClassInst.heapFloat[r21 + numDefine126];
                                                                    f13 = heapClassInst.heapFloat[r21 + numDefine86];
                                                                    f14 = heapClassInst.heapFloat[r21 + numDefine87];
                                                                    f8 = f8 * f11;
                                                                    f3 = f12 + f3;
                                                                    f8 = f8 * f13;
                                                                    heapClassInst.heapFloat[r21 + numDefine126] = f3;
                                                                    f3 = f8 * f10;
                                                                    f8 = heapClassInst.heapFloat[r21 + numDefine127];
                                                                    f9 = f9 * f11;
                                                                    f3 = f8 + f3;
                                                                    f8 = f9 * f14;
                                                                    heapClassInst.heapFloat[r21 + numDefine127] = f3;
                                                                    f3 = f8 * f10;
                                                                    f8 = heapClassInst.heapFloat[r21 + numDefine128];
                                                                    f3 = f8 + f3;
                                                                    heapClassInst.heapFloat[r21 + numDefine128] = f3;
                                                                    f3 = heapClassInst.heapFloat[r21 + numDefine134];
                                                                    f3 = f3 * f10;
                                                                    f8 = heapClassInst.heapFloat[r17 + numDefine12];
                                                                    f9 = heapClassInst.heapFloat[r21 + numDefine136];
                                                                    f11 = heapClassInst.heapFloat[r21 + numDefine135];
                                                                    f3 = f8 * f3;
                                                                    f8 = heapClassInst.heapFloat[r21 + numDefine130];
                                                                    f12 = heapClassInst.heapFloat[r17 + numDefine14];
                                                                    f13 = heapClassInst.heapFloat[r17 + numDefine13];
                                                                    f3 = f8 + f3;
                                                                    f8 = f11 * f10;
                                                                    heapClassInst.heapFloat[r21 + numDefine130] = f3;
                                                                    f3 = f13 * f8;
                                                                    f8 = heapClassInst.heapFloat[r21 + numDefine131];
                                                                    f3 = f8 + f3;
                                                                    f8 = f9 * f10;
                                                                    heapClassInst.heapFloat[r21 + numDefine131] = f3;
                                                                    f3 = f12 * f8;
                                                                    f8 = heapClassInst.heapFloat[r21 + numDefine132];
                                                                    f3 = f8 + f3;
                                                                    heapClassInst.heapFloat[r21 + numDefine132] = f3;
                                                                }
                                                            }
                                                            if (!(r16 == 0)) {
                                                                r21 = r16 >> numDefine2;
                                                                f3 = heapClassInst.heapFloat[r21 + numDefine84];
                                                                f8 = 0;
                                                                if (!(f3 == f8)) {
                                                                    f8 = heapClassInst.heapFloat[r17 + numDefine21];
                                                                    f8 = -f8;
                                                                    f9 = heapClassInst.heapFloat[r17 + numDefine4];
                                                                    f9 = f9 * f3;
                                                                    f10 = heapClassInst.heapFloat[r21 + numDefine85];
                                                                    f9 = f9 * f10;
                                                                    f10 = heapClassInst.heapFloat[r17 + numDefine5];
                                                                    f11 = heapClassInst.heapFloat[r17 + numDefine6];
                                                                    f9 = f9 * f8;
                                                                    f12 = heapClassInst.heapFloat[r21 + numDefine126];
                                                                    f13 = heapClassInst.heapFloat[r21 + numDefine86];
                                                                    f14 = heapClassInst.heapFloat[r21 + numDefine87];
                                                                    f15 = heapClassInst.heapFloat[r17 + numDefine16];
                                                                    f16 = heapClassInst.heapFloat[r17 + numDefine17];
                                                                    f17 = heapClassInst.heapFloat[r17 + numDefine18];
                                                                    f10 = f10 * f3;
                                                                    f9 = f12 + f9;
                                                                    f10 = f10 * f13;
                                                                    heapClassInst.heapFloat[r21 + numDefine126] = f9;
                                                                    f9 = f10 * f8;
                                                                    f10 = heapClassInst.heapFloat[r21 + numDefine127];
                                                                    f3 = f11 * f3;
                                                                    f9 = f10 + f9;
                                                                    f3 = f3 * f14;
                                                                    heapClassInst.heapFloat[r21 + numDefine127] = f9;
                                                                    f3 = f3 * f8;
                                                                    f9 = heapClassInst.heapFloat[r21 + numDefine128];
                                                                    f3 = f9 + f3;
                                                                    heapClassInst.heapFloat[r21 + numDefine128] = f3;
                                                                    f3 = heapClassInst.heapFloat[r21 + numDefine134];
                                                                    f3 = f3 * f8;
                                                                    f9 = heapClassInst.heapFloat[r21 + numDefine136];
                                                                    f10 = heapClassInst.heapFloat[r21 + numDefine135];
                                                                    f11 = heapClassInst.heapFloat[r21 + numDefine130];
                                                                    f3 = f3 * f15;
                                                                    f3 = f11 - f3;
                                                                    f10 = f10 * f8;
                                                                    heapClassInst.heapFloat[r21 + numDefine130] = f3;
                                                                    f3 = f10 * f16;
                                                                    f10 = heapClassInst.heapFloat[r21 + numDefine131];
                                                                    f3 = f10 - f3;
                                                                    f8 = f9 * f8;
                                                                    heapClassInst.heapFloat[r21 + numDefine131] = f3;
                                                                    f3 = f8 * f17;
                                                                    f8 = heapClassInst.heapFloat[r21 + numDefine132];
                                                                    f3 = f8 - f3;
                                                                    heapClassInst.heapFloat[r21 + numDefine132] = f3;
                                                                }
                                                            }
                                                        }
                                                        heapClassInst.heap32[r17 + numDefine20] = 0;
                                                        if (r20 != 0) {
                                                            r21 = r20 >> numDefine2;
                                                            f9 = heapClassInst.heapFloat[r21 + numDefine76];
                                                            f8 = heapClassInst.heapFloat[r21 + numDefine77];
                                                            f3 = heapClassInst.heapFloat[r21 + numDefine78];
                                                        } else {
                                                            f3 = 0;
                                                            f8 = f3;
                                                            f9 = f3;
                                                        }
                                                        f10 = heapClassInst.heapFloat[r17 + numDefine4];
                                                        f11 = heapClassInst.heapFloat[r17 + numDefine5];
                                                        f12 = heapClassInst.heapFloat[r17 + numDefine6];
                                                        f9 = f10 * f9;
                                                        f8 = f11 * f8;
                                                        f8 = f9 + f8;
                                                        f3 = f12 * f3;
                                                        f3 = f8 + f3;
                                                        if (r20 != 0) {
                                                            r20 = r20 >> numDefine2;
                                                            f13 = heapClassInst.heapFloat[r20 + numDefine80];
                                                            f9 = heapClassInst.heapFloat[r20 + numDefine81];
                                                            f8 = heapClassInst.heapFloat[r20 + numDefine82];
                                                        } else {
                                                            f8 = 0;
                                                            f9 = f8;
                                                            f13 = f8;
                                                        }
                                                        f14 = heapClassInst.heapFloat[r17];
                                                        f15 = heapClassInst.heapFloat[r17 + 1];
                                                        f13 = f14 * f13;
                                                        f9 = f15 * f9;
                                                        f14 = heapClassInst.heapFloat[r17 + numDefine2];
                                                        f9 = f13 + f9;
                                                        f8 = f14 * f8;
                                                        f8 = f9 + f8;
                                                        f3 = f3 + f8;
                                                        if (r16 != 0) {
                                                            r20 = r16 >> numDefine2;
                                                            f13 = heapClassInst.heapFloat[r20 + numDefine80];
                                                            f9 = heapClassInst.heapFloat[r20 + numDefine81];
                                                            f8 = heapClassInst.heapFloat[r20 + numDefine82];
                                                        } else {
                                                            f8 = 0;
                                                            f9 = f8;
                                                            f13 = f8;
                                                        }
                                                        f14 = heapClassInst.heapFloat[r17 + numDefine8];
                                                        f15 = heapClassInst.heapFloat[r17 + numDefine9];
                                                        f13 = f14 * f13;
                                                        f9 = f15 * f9;
                                                        f14 = heapClassInst.heapFloat[r17 + numDefine10];
                                                        f9 = f13 + f9;
                                                        f8 = f14 * f8;
                                                        f8 = f9 + f8;
                                                        if (r16 != 0) {
                                                            r16 = r16 >> numDefine2;
                                                            f14 = heapClassInst.heapFloat[r16 + numDefine76];
                                                            f13 = heapClassInst.heapFloat[r16 + numDefine77];
                                                            f9 = heapClassInst.heapFloat[r16 + numDefine78];
                                                        } else {
                                                            f9 = 0;
                                                            f13 = f9;
                                                            f14 = f9;
                                                        }
                                                        f10 = f10 * f14;
                                                        f11 = f11 * f13;
                                                        f10 = f10 + f11;
                                                        f9 = f12 * f9;
                                                        f9 = f10 + f9;
                                                        f10 = heapClassInst.heapFloat[r6 + numDefine8];
                                                        f11 = -f5;
                                                        f8 = f8 - f9;
                                                        f9 = f10 * f11;
                                                        f10 = heapClassInst.heapFloat[r6 + numDefine3];
                                                        f3 = f3 + f8;
                                                        f8 = f9 / f10;
                                                        f9 = heapClassInst.heapFloat[r17 + numDefine23];
                                                        f3 = f7 - f3;
                                                        f7 = f9 * f8;
                                                        f3 = f9 * f3;
                                                        r16 = heapClassInst.heap32[r6 + numDefine11];
                                                        if (r16 == 0) {
                                                            label = numDefine174;
                                                        } else {
                                                            f8 = heapClassInst.heapFloat[r6 + numDefine12];
                                                            if (f8 >= f5) {
                                                                heapClassInst.heapFloat[r17 + numDefine29] = f3;
                                                                heapClassInst.heapFloat[r17 + numDefine33] = f7;
                                                                label = numDefine176;
                                                            } else {
                                                                label = numDefine174;
                                                            }
                                                        }
                                                        if (label == numDefine174) {
                                                            f3 = f7 + f3;
                                                            heapClassInst.heapFloat[r17 + numDefine29] = f3;
                                                            heapClassInst.heap32[r17 + numDefine33] = 0;
                                                        }
                                                        heapClassInst.heap32[r17 + numDefine30] = 0;
                                                        heapClassInst.heap32[r17 + numDefine31] = 0;
                                                        heapClassInst.heap32[r17 + numDefine32] = (int) numDefine54297;
                                                        r16 = heapClassInst.heap32[r2 + numDefine12];
                                                        heapClassInst.heap32[r17 + numDefine25] = r16;
                                                        r16 = heapClassInst.heapU8[r5 + numDefine60];
                                                        r16 = r16 & numDefine32;
                                                        if (r16 == 0) {
                                                            label = numDefine178;
                                                        } else {
                                                            r16 = heapClassInst.heapU8[r8 + numDefine120];
                                                            if (r16 != 0) {
                                                                r16 = r8 >> numDefine2;
                                                                f0 = heapClassInst.heapFloat[r9 + numDefine35];
                                                                f1 = heapClassInst.heapFloat[r16 + numDefine33];
                                                                heapClassInst.heap32[g0] = r0;
                                                                heapClassInst.heap32[g0 + 1] = r12;
                                                                heapClassInst.heap32[g0 + numDefine2] = r14;
                                                                heapClassInst.heap32[g0 + numDefine3] = r10;
                                                                heapClassInst.heap32[g0 + numDefine4] = r19;
                                                                heapClassInst.heap32[g0 + numDefine5] = r18;
                                                                heapClassInst.heap32[g0 + numDefine6] = r3;
                                                                heapClassInst.heap32[g0 + numDefine7] = r1;
                                                                heapClassInst.heap32[g0 + numDefine8] = (int) numDefine53216;
                                                                heapClassInst.heapFloat[g0 + numDefine9] = f1;
                                                                heapClassInst.heapFloat[g0 + numDefine10] = f0;
                                                                zn35btSVector3P11(i7);
                                                                r12 = heapClassInst.heapU8[r5 + numDefine60];
                                                                r12 = r12 & numDefine16;
                                                                if (r12 == 0) {
                                                                    label = numDefine194;
                                                                } else {
                                                                    r12 = r8 >> numDefine2;
                                                                    r8 = r8 >> numDefine2;
                                                                    f0 = heapClassInst.heapFloat[r12 + numDefine36];
                                                                    f1 = heapClassInst.heapFloat[r8 + numDefine34];
                                                                    heapClassInst.heap32[g0] = r0;
                                                                    heapClassInst.heap32[g0 + 1] = r11;
                                                                    heapClassInst.heap32[g0 + numDefine2] = r14;
                                                                    heapClassInst.heap32[g0 + numDefine3] = r10;
                                                                    heapClassInst.heap32[g0 + numDefine4] = r19;
                                                                    heapClassInst.heap32[g0 + numDefine5] = r18;
                                                                    heapClassInst.heap32[g0 + numDefine6] = r3;
                                                                    heapClassInst.heap32[g0 + numDefine7] = r1;
                                                                    heapClassInst.heap32[g0 + numDefine8] = (int) numDefine53216;
                                                                    heapClassInst.heapFloat[g0 + numDefine9] = f1;
                                                                    heapClassInst.heapFloat[g0 + numDefine10] = f0;
                                                                    zn35btSVector3P11(i7);
                                                                    label = numDefine194;
                                                                }
                                                            } else {
                                                                label = numDefine178;
                                                            }
                                                        }
                                                        repeat259:
                                                        do {
                                                            if (label == numDefine178) {
                                                                f3 = heapClassInst.heapFloat[r23 + numDefine17];
                                                                f5 = heapClassInst.heapFloat[r22 + numDefine19];
                                                                f7 = heapClassInst.heapFloat[r24 + numDefine18];
                                                                f8 = f3 * f2;
                                                                f0 = f0 - f8;
                                                                f8 = f7 * f2;
                                                                r16 = r8 >> numDefine2;
                                                                f1 = f1 - f8;
                                                                f2 = f5 * f2;
                                                                r20 = r8 >> numDefine2;
                                                                heapClassInst.heapFloat[r16 + numDefine38] = f0;
                                                                f2 = f4 - f2;
                                                                r21 = r8 >> numDefine2;
                                                                heapClassInst.heapFloat[r20 + numDefine39] = f1;
                                                                r25 = r8 >> numDefine2;
                                                                heapClassInst.heapFloat[r21 + numDefine40] = f2;
                                                                heapClassInst.heap32[r25 + numDefine41] = 0;
                                                                r25 = heapClassInst.heapU8[r5 + numDefine60];
                                                                r25 = r25 & numDefine64;
                                                                if (!(r25 != 0)) {
                                                                    f0 = f0 * f0;
                                                                    f1 = f1 * f1;
                                                                    f0 = f0 + f1;
                                                                    f1 = f2 * f2;
                                                                    f0 = f0 + f1;
                                                                    f1 = (float) numDefineFloat1257;
                                                                    if (!(f0 <= f1)) {
                                                                        heapClassInst.heapFloat[g0] = f0;
                                                                        sqrtf(i7);
                                                                        f3 = (float) (f6 / commonVariable.fg0);
                                                                        f5 = heapClassInst.heapFloat[r16 + numDefine38];
                                                                        f5 = f5 * f3;
                                                                        heapClassInst.heapFloat[r16 + numDefine38] = f5;
                                                                        f7 = heapClassInst.heapFloat[r20 + numDefine39];
                                                                        f7 = f7 * f3;
                                                                        heapClassInst.heapFloat[r20 + numDefine39] = f7;
                                                                        f0 = heapClassInst.heapFloat[r21 + numDefine40];
                                                                        f3 = f0 * f3;
                                                                        heapClassInst.heapFloat[r21 + numDefine40] = f3;
                                                                        r16 = heapClassInst.heapU8[r5 + numDefine60];
                                                                        r16 = r16 & numDefine16;
                                                                        if (!(r16 == 0)) {
                                                                            f0 = heapClassInst.heapFloat[r22 + numDefine19];
                                                                            f1 = heapClassInst.heapFloat[r24 + numDefine18];
                                                                            f2 = heapClassInst.heapFloat[r23 + numDefine17];
                                                                            f4 = f7 * f0;
                                                                            f8 = f3 * f1;
                                                                            f4 = f4 - f8;
                                                                            f3 = f3 * f2;
                                                                            f0 = f5 * f0;
                                                                            r16 = r8 >> numDefine2;
                                                                            f3 = f3 - f0;
                                                                            f5 = f5 * f1;
                                                                            f7 = f7 * f2;
                                                                            r20 = r8 >> numDefine2;
                                                                            heapClassInst.heapFloat[r16 + numDefine42] = f4;
                                                                            f5 = f5 - f7;
                                                                            r21 = r8 >> numDefine2;
                                                                            heapClassInst.heapFloat[r20 + numDefine43] = f3;
                                                                            f7 = f4 * f4;
                                                                            f3 = f3 * f3;
                                                                            r22 = r8 >> numDefine2;
                                                                            heapClassInst.heapFloat[r21 + numDefine44] = f5;
                                                                            heapClassInst.heap32[r22 + numDefine45] = 0;
                                                                            f3 = f7 + f3;
                                                                            f5 = f5 * f5;
                                                                            f3 = f3 + f5;
                                                                            heapClassInst.heapFloat[g0] = f3;
                                                                            sqrtf(i7);
                                                                            f3 = (float) (f6 / commonVariable.fg0);
                                                                            f5 = heapClassInst.heapFloat[r16 + numDefine42];
                                                                            f5 = f5 * f3;
                                                                            heapClassInst.heapFloat[r16 + numDefine42] = f5;
                                                                            f5 = heapClassInst.heapFloat[r20 + numDefine43];
                                                                            f5 = f5 * f3;
                                                                            heapClassInst.heapFloat[r20 + numDefine43] = f5;
                                                                            f5 = heapClassInst.heapFloat[r21 + numDefine44];
                                                                            f3 = f5 * f3;
                                                                            heapClassInst.heapFloat[r21 + numDefine44] = f3;
                                                                            heapClassInst.heap32[g0] = r3;
                                                                            heapClassInst.heap32[g0 + 1] = r11;
                                                                            z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(i7);
                                                                            heapClassInst.heap32[g0] = r1;
                                                                            heapClassInst.heap32[g0 + 1] = r11;
                                                                            z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(i7);
                                                                            heapClassInst.heap32[g0] = r0;
                                                                            heapClassInst.heap32[g0 + 1] = r11;
                                                                            heapClassInst.heap32[g0 + numDefine2] = r14;
                                                                            heapClassInst.heap32[g0 + numDefine3] = r10;
                                                                            heapClassInst.heap32[g0 + numDefine4] = r19;
                                                                            heapClassInst.heap32[g0 + numDefine5] = r18;
                                                                            heapClassInst.heap32[g0 + numDefine6] = r3;
                                                                            heapClassInst.heap32[g0 + numDefine7] = r1;
                                                                            heapClassInst.heap32[g0 + numDefine8] = (int) numDefine53216;
                                                                            heapClassInst.heap32[g0 + numDefine9] = 0;
                                                                            heapClassInst.heap32[g0 + numDefine10] = 0;
                                                                            zn35btSVector3P11(i7);
                                                                        }
                                                                        heapClassInst.heap32[g0] = r3;
                                                                        heapClassInst.heap32[g0 + 1] = r12;
                                                                        z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(i7);
                                                                        heapClassInst.heap32[g0] = r1;
                                                                        heapClassInst.heap32[g0 + 1] = r12;
                                                                        z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(i7);
                                                                        heapClassInst.heap32[g0] = r0;
                                                                        heapClassInst.heap32[g0 + 1] = r12;
                                                                        heapClassInst.heap32[g0 + numDefine2] = r14;
                                                                        heapClassInst.heap32[g0 + numDefine3] = r10;
                                                                        heapClassInst.heap32[g0 + numDefine4] = r19;
                                                                        heapClassInst.heap32[g0 + numDefine5] = r18;
                                                                        heapClassInst.heap32[g0 + numDefine6] = r3;
                                                                        heapClassInst.heap32[g0 + numDefine7] = r1;
                                                                        heapClassInst.heap32[g0 + numDefine8] = (int) numDefine53216;
                                                                        heapClassInst.heap32[g0 + numDefine9] = 0;
                                                                        heapClassInst.heap32[g0 + numDefine10] = 0;
                                                                        r10 = 1;
                                                                        zn35btSVector3P11(i7);
                                                                        heapClassInst.heap8[r8 + numDefine120] = (byte) r10;
                                                                        break repeat259;
                                                                    }
                                                                }
                                                                f0 = 0;
                                                                if (f5 < f0) {
                                                                    f0 = -f5;
                                                                } else {
                                                                    f0 = f5;
                                                                }
                                                                f1 = (float) numDefineFloat742;
                                                                if (f0 <= f1) {
                                                                    f3 = f3 * f3;
                                                                    f0 = f7 * f7;
                                                                    f3 = f3 + f0;
                                                                    heapClassInst.heapFloat[g0] = f3;
                                                                    sqrtf(i7);
                                                                    f1 = heapClassInst.heapFloat[r24 + numDefine18];
                                                                    f0 = (float) (f6 / commonVariable.fg0);
                                                                    f1 = -f1;
                                                                    f1 = f0 * f1;
                                                                    heapClassInst.heapFloat[r16 + numDefine38] = f1;
                                                                    f2 = heapClassInst.heapFloat[r23 + numDefine17];
                                                                    f2 = f2 * f0;
                                                                    heapClassInst.heapFloat[r20 + numDefine39] = f2;
                                                                    heapClassInst.heap32[r21 + numDefine40] = 0;
                                                                    f4 = heapClassInst.heapFloat[r22 + numDefine19];
                                                                    f5 = -f4;
                                                                    r16 = r8 >> numDefine2;
                                                                    f2 = f2 * f5;
                                                                    f3 = f3 * f0;
                                                                    r20 = r8 >> numDefine2;
                                                                    f0 = f4 * f1;
                                                                    heapClassInst.heapFloat[r16 + numDefine42] = f2;
                                                                    heapClassInst.heapFloat[r20 + numDefine43] = f0;
                                                                } else {
                                                                    f3 = f7 * f7;
                                                                    f7 = f5 * f5;
                                                                    f3 = f3 + f7;
                                                                    heapClassInst.heapFloat[g0] = f3;
                                                                    sqrtf(i7);
                                                                    heapClassInst.heap32[r16 + numDefine38] = 0;
                                                                    f0 = heapClassInst.heapFloat[r22 + numDefine19];
                                                                    f6 = (float) (f6 / commonVariable.fg0);
                                                                    f7 = -f0;
                                                                    f7 = f6 * f7;
                                                                    heapClassInst.heapFloat[r20 + numDefine39] = f7;
                                                                    f0 = heapClassInst.heapFloat[r24 + numDefine18];
                                                                    f0 = f0 * f6;
                                                                    r16 = r8 >> numDefine2;
                                                                    f3 = f3 * f6;
                                                                    heapClassInst.heapFloat[r21 + numDefine40] = f0;
                                                                    heapClassInst.heapFloat[r16 + numDefine42] = f3;
                                                                    f3 = heapClassInst.heapFloat[r23 + numDefine17];
                                                                    f6 = -f3;
                                                                    f3 = f3 * f7;
                                                                    r16 = r8 >> numDefine2;
                                                                    f6 = f0 * f6;
                                                                    heapClassInst.heapFloat[r16 + numDefine43] = f6;
                                                                }
                                                                r16 = r8 >> numDefine2;
                                                                heapClassInst.heapFloat[r16 + numDefine44] = f3;
                                                                r16 = heapClassInst.heapU8[r5 + numDefine60];
                                                                r16 = r16 & numDefine16;
                                                                if (!(r16 == 0)) {
                                                                    heapClassInst.heap32[g0] = r3;
                                                                    heapClassInst.heap32[g0 + 1] = r11;
                                                                    z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(i7);
                                                                    heapClassInst.heap32[g0] = r1;
                                                                    heapClassInst.heap32[g0 + 1] = r11;
                                                                    z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(i7);
                                                                    heapClassInst.heap32[g0] = r0;
                                                                    heapClassInst.heap32[g0 + 1] = r11;
                                                                    heapClassInst.heap32[g0 + numDefine2] = r14;
                                                                    heapClassInst.heap32[g0 + numDefine3] = r10;
                                                                    heapClassInst.heap32[g0 + numDefine4] = r19;
                                                                    heapClassInst.heap32[g0 + numDefine5] = r18;
                                                                    heapClassInst.heap32[g0 + numDefine6] = r3;
                                                                    heapClassInst.heap32[g0 + numDefine7] = r1;
                                                                    heapClassInst.heap32[g0 + numDefine8] = (int) numDefine53216;
                                                                    heapClassInst.heap32[g0 + numDefine9] = 0;
                                                                    heapClassInst.heap32[g0 + numDefine10] = 0;
                                                                    zn35btSVector3P11(i7);
                                                                }
                                                                heapClassInst.heap32[g0] = r3;
                                                                heapClassInst.heap32[g0 + 1] = r12;
                                                                z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(i7);
                                                                heapClassInst.heap32[g0] = r1;
                                                                heapClassInst.heap32[g0 + 1] = r12;
                                                                z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(i7);
                                                                heapClassInst.heap32[g0] = r0;
                                                                heapClassInst.heap32[g0 + 1] = r12;
                                                                heapClassInst.heap32[g0 + numDefine2] = r14;
                                                                heapClassInst.heap32[g0 + numDefine3] = r10;
                                                                heapClassInst.heap32[g0 + numDefine4] = r19;
                                                                heapClassInst.heap32[g0 + numDefine5] = r18;
                                                                heapClassInst.heap32[g0 + numDefine6] = r3;
                                                                heapClassInst.heap32[g0 + numDefine7] = r1;
                                                                heapClassInst.heap32[g0 + numDefine8] = (int) numDefine53216;
                                                                heapClassInst.heap32[g0 + numDefine9] = 0;
                                                                heapClassInst.heap32[g0 + numDefine10] = 0;
                                                                r10 = 1;
                                                                zn35btSVector3P11(i7);
                                                                heapClassInst.heap8[r8 + numDefine120] = (byte) r10;
                                                            }
                                                        } while (false);
                                                        r8 = heapClassInst.heap32[r6 + numDefine15];
                                                        r10 = heapClassInst.heap32[r17 + numDefine25];
                                                        r11 = heapClassInst.heap32[r2 + numDefine14];
                                                        r12 = r8 & numDefine8;
                                                        if (r12 == 0) {
                                                            r8 = (r10 * numDefine136) | 0;
                                                            r8 = (r11 + r8) | 0;
                                                            r8 = r8 >> numDefine2;
                                                            heapClassInst.heap32[r8 + numDefine21] = 0;
                                                            r8 = heapClassInst.heapU8[r5 + numDefine60];
                                                            r8 = r8 & numDefine16;
                                                            if (r8 == 0) {
                                                                break repeat153;
                                                            } else {
                                                                r8 = heapClassInst.heap32[r17 + numDefine25];
                                                                r9 = heapClassInst.heap32[r2 + numDefine14];
                                                                r8 = (r8 * numDefine136) | 0;
                                                                r8 = (r8 + r9) | 0;
                                                                r8 = r8 >> numDefine2;
                                                                heapClassInst.heap32[r8 + numDefine55] = 0;
                                                            }
                                                        } else {
                                                            r8 = r8 & numDefine4;
                                                            if (r8 == 0) {
                                                                r10 = (r10 * numDefine136) | 0;
                                                                r10 = (r11 + r10) | 0;
                                                                r10 = r10 >> numDefine2;
                                                                heapClassInst.heap32[r10 + numDefine21] = 0;
                                                            } else {
                                                                r10 = (r10 * numDefine136) | 0;
                                                                r10 = (r11 + r10) | 0;
                                                                f0 = heapClassInst.heapFloat[r9 + numDefine31];
                                                                f1 = heapClassInst.heapFloat[r6 + numDefine14];
                                                                f0 = f0 * f1;
                                                                r10 = r10 >> numDefine2;
                                                                heapClassInst.heapFloat[r10 + numDefine21] = f0;
                                                                if (!(r13 == 0)) {
                                                                    r11 = r13 >> numDefine2;
                                                                    f1 = heapClassInst.heapFloat[r11 + numDefine84];
                                                                    f2 = 0;
                                                                    if (!(f1 == f2)) {
                                                                        f2 = heapClassInst.heapFloat[r10 + numDefine4];
                                                                        f2 = f2 * f1;
                                                                        f3 = heapClassInst.heapFloat[r11 + numDefine85];
                                                                        f2 = f2 * f3;
                                                                        f3 = heapClassInst.heapFloat[r10 + numDefine5];
                                                                        f4 = heapClassInst.heapFloat[r10 + numDefine6];
                                                                        f2 = f2 * f0;
                                                                        f5 = heapClassInst.heapFloat[r11 + numDefine126];
                                                                        f6 = heapClassInst.heapFloat[r11 + numDefine86];
                                                                        f7 = heapClassInst.heapFloat[r11 + numDefine87];
                                                                        f3 = f3 * f1;
                                                                        f2 = f5 + f2;
                                                                        f3 = f3 * f6;
                                                                        heapClassInst.heapFloat[r11 + numDefine126] = f2;
                                                                        f2 = f3 * f0;
                                                                        f3 = heapClassInst.heapFloat[r11 + numDefine127];
                                                                        f1 = f4 * f1;
                                                                        f2 = f3 + f2;
                                                                        f1 = f1 * f7;
                                                                        heapClassInst.heapFloat[r11 + numDefine127] = f2;
                                                                        f1 = f1 * f0;
                                                                        f2 = heapClassInst.heapFloat[r11 + numDefine128];
                                                                        f1 = f2 + f1;
                                                                        heapClassInst.heapFloat[r11 + numDefine128] = f1;
                                                                        f1 = heapClassInst.heapFloat[r11 + numDefine134];
                                                                        f1 = f1 * f0;
                                                                        f2 = heapClassInst.heapFloat[r10 + numDefine12];
                                                                        f3 = heapClassInst.heapFloat[r11 + numDefine136];
                                                                        f4 = heapClassInst.heapFloat[r11 + numDefine135];
                                                                        f1 = f2 * f1;
                                                                        f2 = heapClassInst.heapFloat[r11 + numDefine130];
                                                                        f5 = heapClassInst.heapFloat[r10 + numDefine14];
                                                                        f6 = heapClassInst.heapFloat[r10 + numDefine13];
                                                                        f1 = f2 + f1;
                                                                        f2 = f4 * f0;
                                                                        heapClassInst.heapFloat[r11 + numDefine130] = f1;
                                                                        f1 = f6 * f2;
                                                                        f2 = heapClassInst.heapFloat[r11 + numDefine131];
                                                                        f1 = f2 + f1;
                                                                        f0 = f3 * f0;
                                                                        heapClassInst.heapFloat[r11 + numDefine131] = f1;
                                                                        f0 = f5 * f0;
                                                                        f1 = heapClassInst.heapFloat[r11 + numDefine132];
                                                                        f0 = f1 + f0;
                                                                        heapClassInst.heapFloat[r11 + numDefine132] = f0;
                                                                    }
                                                                }
                                                                if (!(r15 == 0)) {
                                                                    r11 = r15 >> numDefine2;
                                                                    f0 = heapClassInst.heapFloat[r11 + numDefine84];
                                                                    f1 = 0;
                                                                    if (!(f0 == f1)) {
                                                                        f1 = heapClassInst.heapFloat[r10 + numDefine21];
                                                                        f1 = -f1;
                                                                        f2 = heapClassInst.heapFloat[r10 + numDefine4];
                                                                        f2 = f2 * f0;
                                                                        f3 = heapClassInst.heapFloat[r11 + numDefine85];
                                                                        f2 = f2 * f3;
                                                                        f3 = heapClassInst.heapFloat[r10 + numDefine5];
                                                                        f4 = heapClassInst.heapFloat[r10 + numDefine6];
                                                                        f2 = f2 * f1;
                                                                        f5 = heapClassInst.heapFloat[r11 + numDefine126];
                                                                        f6 = heapClassInst.heapFloat[r11 + numDefine86];
                                                                        f7 = heapClassInst.heapFloat[r11 + numDefine87];
                                                                        f8 = heapClassInst.heapFloat[r10 + numDefine16];
                                                                        f9 = heapClassInst.heapFloat[r10 + numDefine17];
                                                                        f10 = heapClassInst.heapFloat[r10 + numDefine18];
                                                                        f3 = f3 * f0;
                                                                        f2 = f5 + f2;
                                                                        f3 = f3 * f6;
                                                                        heapClassInst.heapFloat[r11 + numDefine126] = f2;
                                                                        f2 = f3 * f1;
                                                                        f3 = heapClassInst.heapFloat[r11 + numDefine127];
                                                                        f0 = f4 * f0;
                                                                        f2 = f3 + f2;
                                                                        f0 = f0 * f7;
                                                                        heapClassInst.heapFloat[r11 + numDefine127] = f2;
                                                                        f0 = f0 * f1;
                                                                        f2 = heapClassInst.heapFloat[r11 + numDefine128];
                                                                        f0 = f2 + f0;
                                                                        heapClassInst.heapFloat[r11 + numDefine128] = f0;
                                                                        f0 = heapClassInst.heapFloat[r11 + numDefine134];
                                                                        f0 = f0 * f1;
                                                                        f2 = heapClassInst.heapFloat[r11 + numDefine136];
                                                                        f3 = heapClassInst.heapFloat[r11 + numDefine135];
                                                                        f4 = heapClassInst.heapFloat[r11 + numDefine130];
                                                                        f0 = f0 * f8;
                                                                        f0 = f4 - f0;
                                                                        f3 = f3 * f1;
                                                                        heapClassInst.heapFloat[r11 + numDefine130] = f0;
                                                                        f0 = f3 * f9;
                                                                        f3 = heapClassInst.heapFloat[r11 + numDefine131];
                                                                        f0 = f3 - f0;
                                                                        f1 = f2 * f1;
                                                                        heapClassInst.heapFloat[r11 + numDefine131] = f0;
                                                                        f0 = f1 * f10;
                                                                        f1 = heapClassInst.heapFloat[r11 + numDefine132];
                                                                        f0 = f1 - f0;
                                                                        heapClassInst.heapFloat[r11 + numDefine132] = f0;
                                                                    }
                                                                }
                                                            }
                                                            r10 = heapClassInst.heap32[r6 + numDefine15];
                                                            r11 = r10 & numDefine16;
                                                            if (!(r11 == 0)) {
                                                                r11 = heapClassInst.heap32[r17 + numDefine25];
                                                                r17 = heapClassInst.heap32[r2 + numDefine14];
                                                                r10 = r10 & numDefine4;
                                                                if (r10 == 0) {
                                                                    r10 = (r11 * numDefine136) | 0;
                                                                    r10 = (r17 + r10) | 0;
                                                                    r10 = r10 >> numDefine2;
                                                                    heapClassInst.heap32[r10 + numDefine55] = 0;
                                                                } else {
                                                                    r11 = (r11 * numDefine136) | 0;
                                                                    r11 = (r17 + r11) | 0;
                                                                    f0 = heapClassInst.heapFloat[r9 + numDefine32];
                                                                    f1 = heapClassInst.heapFloat[r6 + numDefine14];
                                                                    f0 = f0 * f1;
                                                                    r11 = r11 >> numDefine2;
                                                                    heapClassInst.heapFloat[r11 + numDefine55] = f0;
                                                                    if (!(r13 == 0)) {
                                                                        r17 = r13 >> numDefine2;
                                                                        f1 = heapClassInst.heapFloat[r17 + numDefine84];
                                                                        f2 = 0;
                                                                        if (!(f1 == f2)) {
                                                                            f2 = heapClassInst.heapFloat[r11 + numDefine38];
                                                                            f2 = f2 * f1;
                                                                            f3 = heapClassInst.heapFloat[r11 + numDefine39];
                                                                            f4 = heapClassInst.heapFloat[r11 + numDefine40];
                                                                            f5 = heapClassInst.heapFloat[r17 + numDefine126];
                                                                            f2 = f2 * f0;
                                                                            f2 = f5 + f2;
                                                                            f3 = f3 * f1;
                                                                            heapClassInst.heapFloat[r17 + numDefine126] = f2;
                                                                            f2 = f3 * f0;
                                                                            f3 = heapClassInst.heapFloat[r17 + numDefine127];
                                                                            f2 = f3 + f2;
                                                                            f1 = f4 * f1;
                                                                            heapClassInst.heapFloat[r17 + numDefine127] = f2;
                                                                            f1 = f1 * f0;
                                                                            f2 = heapClassInst.heapFloat[r17 + numDefine128];
                                                                            f1 = f2 + f1;
                                                                            heapClassInst.heapFloat[r17 + numDefine128] = f1;
                                                                            f1 = heapClassInst.heapFloat[r17 + numDefine134];
                                                                            f1 = f1 * f0;
                                                                            f2 = heapClassInst.heapFloat[r11 + numDefine46];
                                                                            f3 = heapClassInst.heapFloat[r17 + numDefine136];
                                                                            f4 = heapClassInst.heapFloat[r17 + numDefine135];
                                                                            f1 = f2 * f1;
                                                                            f2 = heapClassInst.heapFloat[r17 + numDefine130];
                                                                            f5 = heapClassInst.heapFloat[r11 + numDefine48];
                                                                            f6 = heapClassInst.heapFloat[r11 + numDefine47];
                                                                            f1 = f2 + f1;
                                                                            f2 = f4 * f0;
                                                                            heapClassInst.heapFloat[r17 + numDefine130] = f1;
                                                                            f1 = f6 * f2;
                                                                            f2 = heapClassInst.heapFloat[r17 + numDefine131];
                                                                            f1 = f2 + f1;
                                                                            f0 = f3 * f0;
                                                                            heapClassInst.heapFloat[r17 + numDefine131] = f1;
                                                                            f0 = f5 * f0;
                                                                            f1 = heapClassInst.heapFloat[r17 + numDefine132];
                                                                            f0 = f1 + f0;
                                                                            heapClassInst.heapFloat[r17 + numDefine132] = f0;
                                                                        }
                                                                    }
                                                                    if (!(r15 == 0)) {
                                                                        r17 = r15 >> numDefine2;
                                                                        f0 = heapClassInst.heapFloat[r17 + numDefine84];
                                                                        f1 = 0;
                                                                        if (!(f0 == f1)) {
                                                                            f1 = heapClassInst.heapFloat[r11 + numDefine55];
                                                                            f1 = -f1;
                                                                            f2 = heapClassInst.heapFloat[r11 + numDefine38];
                                                                            f2 = f2 * f0;
                                                                            f3 = heapClassInst.heapFloat[r11 + numDefine39];
                                                                            f4 = heapClassInst.heapFloat[r11 + numDefine40];
                                                                            f2 = f2 * f1;
                                                                            f5 = heapClassInst.heapFloat[r17 + numDefine126];
                                                                            f6 = heapClassInst.heapFloat[r11 + numDefine50];
                                                                            f7 = heapClassInst.heapFloat[r11 + numDefine51];
                                                                            f8 = heapClassInst.heapFloat[r11 + numDefine52];
                                                                            f2 = f5 + f2;
                                                                            f3 = f3 * f0;
                                                                            heapClassInst.heapFloat[r17 + numDefine126] = f2;
                                                                            f2 = f3 * f1;
                                                                            f3 = heapClassInst.heapFloat[r17 + numDefine127];
                                                                            f2 = f3 + f2;
                                                                            f0 = f4 * f0;
                                                                            heapClassInst.heapFloat[r17 + numDefine127] = f2;
                                                                            f0 = f0 * f1;
                                                                            f2 = heapClassInst.heapFloat[r17 + numDefine128];
                                                                            f0 = f2 + f0;
                                                                            heapClassInst.heapFloat[r17 + numDefine128] = f0;
                                                                            f0 = heapClassInst.heapFloat[r17 + numDefine134];
                                                                            f0 = f0 * f1;
                                                                            f2 = heapClassInst.heapFloat[r17 + numDefine136];
                                                                            f3 = heapClassInst.heapFloat[r17 + numDefine135];
                                                                            f4 = heapClassInst.heapFloat[r17 + numDefine130];
                                                                            f0 = f0 * f6;
                                                                            f0 = f4 - f0;
                                                                            f3 = f3 * f1;
                                                                            heapClassInst.heapFloat[r17 + numDefine130] = f0;
                                                                            f0 = f3 * f7;
                                                                            f3 = heapClassInst.heapFloat[r17 + numDefine131];
                                                                            f0 = f3 - f0;
                                                                            f1 = f2 * f1;
                                                                            heapClassInst.heapFloat[r17 + numDefine131] = f0;
                                                                            f0 = f1 * f8;
                                                                            f1 = heapClassInst.heapFloat[r17 + numDefine132];
                                                                            f0 = f1 - f0;
                                                                            heapClassInst.heapFloat[r17 + numDefine132] = f0;
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                } while (false);
                                                r7 = (r7 + 1) | 0;
                                                r4 = (r4 + numDefine276) | 0;
                                            } else {
                                                break repeat150;
                                            }
                                        }
                                    }
                                    r1 = heapClassInst.heap32[fp + numDefineNeg133];
                                    r1 = (r1 + -1) | 0;
                                    heapClassInst.heap32[fp + numDefineNeg133] = r1;
                                    r3 = heapClassInst.heap32[fp + numDefineNeg132];
                                    r3 = (r3 + numDefine4) | 0;
                                    heapClassInst.heap32[fp + numDefineNeg132] = r3;
                                    if (!(r1 != 0)) {
                                        break repeat132;
                                    }
                                }
                            }
                        } while (false);
                        r1 = heapClassInst.heap32[r2 + numDefine17];
                        r3 = heapClassInst.heap32[r2 + numDefine2];
                        r4 = heapClassInst.heap32[r2 + numDefine12];
                        repeat307:
                        do {
                            if (!(r1 > r3)) {
                                if (!(r1 >= r3)) {
                                    r5 = heapClassInst.heap32[r2 + numDefine18];
                                    if (!(r5 >= r3)) {
                                        if (r3 != 0) {
                                            r5 = gNumAlignedAllocs;
                                            r5 = r5 >> numDefine2;
                                            r6 = heapClassInst.heap32[r5];
                                            r7 = r3 << numDefine2;
                                            r6 = (r6 + 1) | 0;
                                            r7 = r7 | numDefine3;
                                            heapClassInst.heap32[r5] = r6;
                                            r5 = (r7 + numDefine16) | 0;
                                            heapClassInst.heap32[g0] = r5;
                                            mallocNew(i7);
                                            r5 = commonVariable.rg0;
                                            if (r5 != 0) {
                                                r6 = 0;
                                                r7 = (r5 + numDefine4) | 0;
                                                r6 = (r6 - r7) | 0;
                                                r6 = r6 & numDefine15;
                                                r6 = (r5 + r6) | 0;
                                                r7 = (r6 + numDefine4) | 0;
                                                r6 = r6 >> numDefine2;
                                                heapClassInst.heap32[r6] = r5;
                                                r5 = r7;
                                            }
                                        } else {
                                            r5 = 0;
                                        }
                                        r6 = (r0 + numDefine76) | 0;
                                        if (r1 < 1) {
                                            r7 = r6 >> numDefine2;
                                            r8 = heapClassInst.heap32[r7];
                                        } else {
                                            r7 = 0;
                                            repeat320:
                                            while (true) {
                                                r8 = r6 >> numDefine2;
                                                r8 = heapClassInst.heap32[r8];
                                                r9 = r7 << numDefine2;
                                                r10 = (r8 + r9) | 0;
                                                r10 = r10 >> numDefine2;
                                                r9 = (r5 + r9) | 0;
                                                r10 = heapClassInst.heap32[r10];
                                                r7 = (r7 + 1) | 0;
                                                r9 = r9 >> numDefine2;
                                                heapClassInst.heap32[r9] = r10;
                                                if (!(r1 != r7)) {
                                                    break repeat320;
                                                }
                                            }
                                            r6 = (r0 + numDefine76) | 0;
                                        }
                                        if (!(r8 == 0)) {
                                            r7 = heapClassInst.heapU8[r0 + numDefine80];
                                            if (!(r7 == 0)) {
                                                r7 = gNumAlignedFree;
                                                r7 = r7 >> numDefine2;
                                                r9 = heapClassInst.heap32[r7];
                                                r9 = (r9 + 1) | 0;
                                                r8 = r8 >> numDefine2;
                                                heapClassInst.heap32[r7] = r9;
                                                r7 = heapClassInst.heap32[r8 + -1];
                                                heapClassInst.heap32[g0] = r7;
                                                free(i7);
                                            }
                                            r7 = r6 >> numDefine2;
                                            heapClassInst.heap32[r7] = 0;
                                        }
                                        r7 = 1;
                                        r6 = r6 >> numDefine2;
                                        heapClassInst.heap8[r0 + numDefine80] = (byte) r7;
                                        heapClassInst.heap32[r6] = r5;
                                        heapClassInst.heap32[r2 + numDefine18] = r3;
                                        if (r1 >= r3) {
                                            break repeat307;
                                        }
                                    }
                                    while (true) {
                                        r5 = r1 << numDefine2;
                                        r6 = heapClassInst.heap32[r2 + numDefine19];
                                        r5 = (r6 + r5) | 0;
                                        r1 = (r1 + 1) | 0;
                                        r5 = r5 >> numDefine2;
                                        heapClassInst.heap32[r5] = 0;
                                        if (!(r3 != r1)) {
                                            break repeat307;
                                        }
                                    }
                                }
                            }
                        } while (false);
                        heapClassInst.heap32[r2 + numDefine17] = r3;
                        r1 = heapClassInst.heap32[r2 + numDefine22];
                        repeat333:
                        do {
                            if (!(r1 > r4)) {
                                if (!(r1 >= r4)) {
                                    r5 = heapClassInst.heap32[r2 + numDefine23];
                                    if (!(r5 >= r4)) {
                                        if (r4 != 0) {
                                            r5 = gNumAlignedAllocs;
                                            r5 = r5 >> numDefine2;
                                            r6 = heapClassInst.heap32[r5];
                                            r7 = r4 << numDefine2;
                                            r6 = (r6 + 1) | 0;
                                            r7 = r7 | numDefine3;
                                            heapClassInst.heap32[r5] = r6;
                                            r5 = (r7 + numDefine16) | 0;
                                            heapClassInst.heap32[g0] = r5;
                                            mallocNew(i7);
                                            r5 = commonVariable.rg0;
                                            if (r5 != 0) {
                                                r6 = 0;
                                                r7 = (r5 + numDefine4) | 0;
                                                r6 = (r6 - r7) | 0;
                                                r6 = r6 & numDefine15;
                                                r6 = (r5 + r6) | 0;
                                                r7 = (r6 + numDefine4) | 0;
                                                r6 = r6 >> numDefine2;
                                                heapClassInst.heap32[r6] = r5;
                                                r5 = r7;
                                            }
                                        } else {
                                            r5 = 0;
                                        }
                                        r6 = (r0 + numDefine96) | 0;
                                        if (r1 < 1) {
                                            r7 = r6 >> numDefine2;
                                            r8 = heapClassInst.heap32[r7];
                                        } else {
                                            r7 = 0;
                                            repeat346:
                                            while (true) {
                                                r8 = r6 >> numDefine2;
                                                r8 = heapClassInst.heap32[r8];
                                                r9 = r7 << numDefine2;
                                                r10 = (r8 + r9) | 0;
                                                r10 = r10 >> numDefine2;
                                                r9 = (r5 + r9) | 0;
                                                r10 = heapClassInst.heap32[r10];
                                                r7 = (r7 + 1) | 0;
                                                r9 = r9 >> numDefine2;
                                                heapClassInst.heap32[r9] = r10;
                                                if (!(r1 != r7)) {
                                                    break repeat346;
                                                }
                                            }
                                            r6 = (r0 + numDefine96) | 0;
                                        }
                                        if (!(r8 == 0)) {
                                            r7 = heapClassInst.heapU8[r0 + numDefine100];
                                            if (!(r7 == 0)) {
                                                r7 = gNumAlignedFree;
                                                r7 = r7 >> numDefine2;
                                                r9 = heapClassInst.heap32[r7];
                                                r9 = (r9 + 1) | 0;
                                                r8 = r8 >> numDefine2;
                                                heapClassInst.heap32[r7] = r9;
                                                r7 = heapClassInst.heap32[r8 + -1];
                                                heapClassInst.heap32[g0] = r7;
                                                free(i7);
                                            }
                                            r7 = r6 >> numDefine2;
                                            heapClassInst.heap32[r7] = 0;
                                        }
                                        r7 = 1;
                                        r6 = r6 >> numDefine2;
                                        heapClassInst.heap8[r0 + numDefine100] = (byte) r7;
                                        heapClassInst.heap32[r6] = r5;
                                        heapClassInst.heap32[r2 + numDefine23] = r4;
                                        if (r1 >= r4) {
                                            break repeat333;
                                        }
                                    }
                                    while (true) {
                                        r0 = r1 << numDefine2;
                                        r5 = heapClassInst.heap32[r2 + numDefine24];
                                        r0 = (r5 + r0) | 0;
                                        r1 = (r1 + 1) | 0;
                                        r0 = r0 >> numDefine2;
                                        heapClassInst.heap32[r0] = 0;
                                        if (!(r4 != r1)) {
                                            break repeat333;
                                        }
                                    }
                                }
                            }
                        } while (false);
                        heapClassInst.heap32[r2 + numDefine22] = r4;
                        repeat359:
                        do {
                            if (!(r3 < 1)) {
                                r0 = 0;
                                while (true) {
                                    r1 = r0 << numDefine2;
                                    r5 = heapClassInst.heap32[r2 + numDefine19];
                                    r1 = (r5 + r1) | 0;
                                    r5 = (r0 + 1) | 0;
                                    r1 = r1 >> numDefine2;
                                    heapClassInst.heap32[r1] = r0;
                                    r0 = r5;
                                    if (!(r3 != r5)) {
                                        break repeat359;
                                    }
                                }
                            }
                        } while (false);
                        if (r4 < 1) {
                            break repeat1;
                        } else {
                            r0 = 0;
                            while (true) {
                                r1 = r0 << numDefine2;
                                r3 = heapClassInst.heap32[r2 + numDefine24];
                                r1 = (r3 + r1) | 0;
                                r3 = (r0 + 1) | 0;
                                r1 = r1 >> numDefine2;
                                heapClassInst.heap32[r1] = r0;
                                r0 = r3;
                                if (!(r4 != r3)) {
                                    break repeat1;
                                }
                            }
                        }
                    case numDefine78:
                        r8 = twoEStr1157;
                        r0 = twoEStr652;
                        heapClassInst.heap32[g0] = r8;
                        heapClassInst.heap32[g0 + 1] = r0;
                        heapClassInst.heap32[g0 + numDefine2] = numDefine813;
                        assertNew(i7);
                        break;
                    default:
                        break;
                }
            }
        } while (false);
        r0 = zn15CProfileManager11CurrentNodeE;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        r2 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + numDefine4];
        r3 = (r3 + -1) | 0;
        heapClassInst.heap32[r2 + numDefine4] = r3;
        repeat369:
        do {
            if (!(r3 != 0)) {
                r3 = heapClassInst.heap32[r2 + 1];
                if (r3 != 0) {
                    r1 = sp + numDefineNeg8;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r3 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r1 = r1 >> numDefine2;
                    r4 = heapClassInst.heap32[fp + numDefineNeg2];
                    r5 = heapClassInst.heap32[r3];
                    r4 = (r4 - r5) | 0;
                    r1 = heapClassInst.heap32[r1 + 1];
                    r3 = heapClassInst.heap32[r3 + 1];
                    r1 = (r1 - r3) | 0;
                    r3 = (int) ((r4 * numDefineN6) | 0);
                    r1 = (r1 + r3) | 0;
                    r3 = heapClassInst.heap32[r2 + numDefine3];
                    r1 = (r1 - r3) | 0;
                    f0 = uint(r1);
                    f1 = numDefine1000;
                    f2 = heapClassInst.heapFloat[r2 + numDefine2];
                    f0 = f0 / f1;
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r2 + numDefine2] = f0;
                    r1 = heapClassInst.heap32[r2 + numDefine4];
                    if (r1 != 0) {
                        break repeat369;
                    } else {
                        r1 = heapClassInst.heap32[r0];
                    }
                }
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1 + numDefine5];
                heapClassInst.heap32[r0] = r1;
            }
        } while (false);
        f0 = 0;
        commonVariable.fg0 = f0;
        
    }

    public static void zn35btSequentialImpulse(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg48;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr854;
        r1 = heapClassInst.heap32[fp + numDefine7];
        heapClassInst.heap32[g0] = r0;
        r0 = heapClassInst.heap32[fp];
        r2 = heapClassInst.heap32[fp + numDefine5];
        r3 = heapClassInst.heap32[fp + numDefine6];
        r4 = r1 >> numDefine2;
        zn15CProfileManager13StartProfileEPKc(i7);
        r5 = heapClassInst.heap32[r4 + numDefine5];
        if (!(r5 < 1)) {
            r5 = 0;
            repeat3:
            while (true) {
                r6 = r0 >> numDefine2;
                r7 = heapClassInst.heap32[r4 + numDefine15];
                r8 = r7 & 1;
                if (r8 != 0) {
                    r8 = r5 & numDefine7;
                    if (!(r8 != 0)) {
                        r7 = heapClassInst.heap32[r6 + numDefine2];
                        r8 = heapClassInst.heap32[r6 + numDefine12];
                        if (!(r7 < 1)) {
                            r9 = 0;
                            r7 = (r9 - r7) | 0;
                            r9 = 1;
                            repeat10:
                            while (true) {
                                r10 = heapClassInst.heap32[r6 + numDefine19];
                                r11 = r9 << numDefine2;
                                r11 = (r10 + r11) | 0;
                                r11 = r11 >> numDefine2;
                                r12 = heapClassInst.heap32[r6 + numDefine31];
                                r13 = heapClassInst.heap32[r11 + -1];
                                r12 = (int) ((r12 * numDefine64525) | 0);
                                r12 = (int) ((r12 + numDefine04223) | 0);
                                heapClassInst.heap32[r6 + numDefine31] = r12;
                                if (uint(r9) < uint(numDefine65537)) {
                                    r14 = r12 >>> numDefine16;
                                    r12 = r14 ^ r12;
                                    if (uint(r9) < uint(numDefine257)) {
                                        r14 = r12 >>> numDefine8;
                                        r12 = r14 ^ r12;
                                        if (uint(r9) < uint(numDefine17)) {
                                            r14 = r12 >>> numDefine4;
                                            r12 = r14 ^ r12;
                                            if (uint(r9) < uint(numDefine5)) {
                                                r14 = r12 >>> numDefine2;
                                                r12 = r14 ^ r12;
                                                if (uint(r9) < uint(numDefine3)) {
                                                    r14 = r12 >>> 1;
                                                    r12 = r14 ^ r12;
                                                }
                                            }
                                        }
                                    }
                                }
                                r12 = (int) Math.floor(uint(r12) % uint(r9));
                                r12 = r12 << numDefine2;
                                r10 = (r10 + r12) | 0;
                                r10 = r10 >> numDefine2;
                                r10 = heapClassInst.heap32[r10];
                                heapClassInst.heap32[r11 + -1] = r10;
                                r10 = heapClassInst.heap32[r6 + numDefine19];
                                r10 = (r10 + r12) | 0;
                                r9 = (r9 + 1) | 0;
                                r10 = r10 >> numDefine2;
                                heapClassInst.heap32[r10] = r13;
                                r10 = (r7 + r9) | 0;
                                if (!(r10 != 1)) {
                                    break repeat10;
                                }
                            }
                        }
                        repeat20:
                        do {
                            if (!(r8 < 1)) {
                                r7 = 0;
                                r7 = (r7 - r8) | 0;
                                r8 = 1;
                                while (true) {
                                    r9 = heapClassInst.heap32[r6 + numDefine24];
                                    r10 = r8 << numDefine2;
                                    r10 = (r9 + r10) | 0;
                                    r10 = r10 >> numDefine2;
                                    r11 = heapClassInst.heap32[r6 + numDefine31];
                                    r12 = heapClassInst.heap32[r10 + -1];
                                    r11 = (int) ((r11 * numDefine64525) | 0);
                                    r11 = (int) ((r11 + numDefine04223) | 0);
                                    heapClassInst.heap32[r6 + numDefine31] = r11;
                                    if (uint(r8) < uint(numDefine65537)) {
                                        r13 = r11 >>> numDefine16;
                                        r11 = r13 ^ r11;
                                        if (uint(r8) < uint(numDefine257)) {
                                            r13 = r11 >>> numDefine8;
                                            r11 = r13 ^ r11;
                                            if (uint(r8) < uint(numDefine17)) {
                                                r13 = r11 >>> numDefine4;
                                                r11 = r13 ^ r11;
                                                if (uint(r8) < uint(numDefine5)) {
                                                    r13 = r11 >>> numDefine2;
                                                    r11 = r13 ^ r11;
                                                    if (uint(r8) < uint(numDefine3)) {
                                                        r13 = r11 >>> 1;
                                                        r11 = r13 ^ r11;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    r11 = (int) Math.floor(uint(r11) % uint(r8));
                                    r11 = r11 << numDefine2;
                                    r9 = (r9 + r11) | 0;
                                    r9 = r9 >> numDefine2;
                                    r9 = heapClassInst.heap32[r9];
                                    heapClassInst.heap32[r10 + -1] = r9;
                                    r9 = heapClassInst.heap32[r6 + numDefine24];
                                    r9 = (r9 + r11) | 0;
                                    r8 = (r8 + 1) | 0;
                                    r9 = r9 >> numDefine2;
                                    heapClassInst.heap32[r9] = r12;
                                    r9 = (r7 + r8) | 0;
                                    if (!(r9 != 1)) {
                                        break repeat20;
                                    }
                                }
                            }
                        } while (false);
                        r7 = heapClassInst.heap32[r4 + numDefine15];
                    }
                }
                r8 = heapClassInst.heap32[r6 + numDefine7];
                r7 = r7 & numDefine256;
                repeat33:
                do {
                    if (r7 != 0) {
                        repeat35:
                        do {
                            if (!(r8 < 1)) {
                                r7 = 0;
                                r8 = r7;
                                while (true) {
                                    r9 = (r8 * numDefine34) | 0;
                                    r10 = heapClassInst.heap32[r6 + numDefine9];
                                    r9 = r9 << numDefine2;
                                    r9 = (r10 + r9) | 0;
                                    r9 = r9 >> numDefine2;
                                    r11 = heapClassInst.heap32[r9 + numDefine27];
                                    r9 = heapClassInst.heap32[r9 + numDefine26];
                                    r10 = (r10 + r7) | 0;
                                    heapClassInst.heap32[g0] = r9;
                                    heapClassInst.heap32[g0 + 1] = r11;
                                    heapClassInst.heap32[g0 + numDefine2] = r10;
                                    r8 = (r8 + 1) | 0;
                                    r7 = (r7 + numDefine136) | 0;
                                    zn35btSequentialImpulseConstraintSolver33resolveSingleConstraintRowGenericER11btRigidBodyS1RK18btSolverConstraint(i7);
                                    r9 = heapClassInst.heap32[r6 + numDefine7];
                                    if (!(r9 > r8)) {
                                        break repeat35;
                                    }
                                }
                            }
                        } while (false);
                        repeat40:
                        do {
                            if (!(r3 < 1)) {
                                r7 = r2;
                                r8 = r3;
                                while (true) {
                                    r9 = r7 >> numDefine2;
                                    r9 = heapClassInst.heap32[r9];
                                    r10 = r9 >> numDefine2;
                                    r11 = heapClassInst.heap32[r10];
                                    r11 = r11 >> numDefine2;
                                    r11 = heapClassInst.heap32[r11 + numDefine6];
                                    f0 = heapClassInst.heapFloat[r4 + numDefine3];
                                    r12 = heapClassInst.heap32[r10 + numDefine6];
                                    r10 = heapClassInst.heap32[r10 + numDefine5];
                                    heapClassInst.heap32[g0] = r9;
                                    heapClassInst.heap32[g0 + 1] = r10;
                                    heapClassInst.heap32[g0 + numDefine2] = r12;
                                    heapClassInst.heapFloat[g0 + numDefine3] = f0;
                                    r8 = (r8 + -1) | 0;
                                    r7 = (r7 + numDefine4) | 0;
                                    functionTable.get(r11 >> numDefine2).accept(i7);
                                    if (!(r8 != 0)) {
                                        break repeat40;
                                    }
                                }
                            }
                        } while (false);
                        r7 = heapClassInst.heap32[r6 + numDefine2];
                        repeat45:
                        do {
                            if (!(r7 < 1)) {
                                r8 = 0;
                                while (true) {
                                    r9 = heapClassInst.heap32[r6 + numDefine19];
                                    r10 = r8 << numDefine2;
                                    r9 = (r9 + r10) | 0;
                                    r9 = r9 >> numDefine2;
                                    r9 = heapClassInst.heap32[r9];
                                    r9 = (r9 * numDefine136) | 0;
                                    r10 = heapClassInst.heap32[r6 + numDefine4];
                                    r9 = (r10 + r9) | 0;
                                    r10 = r9 >> numDefine2;
                                    r11 = heapClassInst.heap32[r10 + numDefine27];
                                    r10 = heapClassInst.heap32[r10 + numDefine26];
                                    heapClassInst.heap32[g0] = r10;
                                    heapClassInst.heap32[g0 + 1] = r11;
                                    heapClassInst.heap32[g0 + numDefine2] = r9;
                                    r8 = (r8 + 1) | 0;
                                    zn35btSequentialImpulseConstraintSolver36resolveSingleConstraintRowLowerLimitER11btRigidBodyS1RK18btSolverConstraint(i7);
                                    if (!(r7 != r8)) {
                                        break repeat45;
                                    }
                                }
                            }
                        } while (false);
                        r7 = heapClassInst.heap32[r6 + numDefine12];
                        if (r7 < 1) {
                            break repeat33;
                        } else {
                            r8 = 0;
                            repeat51:
                            while (true) {
                                r9 = heapClassInst.heap32[r6 + numDefine24];
                                r10 = r8 << numDefine2;
                                r9 = (r9 + r10) | 0;
                                r9 = r9 >> numDefine2;
                                r9 = heapClassInst.heap32[r9];
                                r10 = heapClassInst.heap32[r6 + numDefine14];
                                r9 = (r9 * numDefine136) | 0;
                                r9 = (r10 + r9) | 0;
                                r10 = r9 >> numDefine2;
                                r11 = heapClassInst.heap32[r10 + numDefine25];
                                r12 = heapClassInst.heap32[r6 + numDefine4];
                                r11 = (r11 * numDefine136) | 0;
                                r11 = (r12 + r11) | 0;
                                r11 = r11 >> numDefine2;
                                f0 = heapClassInst.heapFloat[r11 + numDefine21];
                                f1 = 0;
                                if (!(f0 <= f1)) {
                                    f1 = heapClassInst.heapFloat[r10 + numDefine22];
                                    f0 = f1 * f0;
                                    f1 = -f0;
                                    heapClassInst.heapFloat[r10 + numDefine31] = f1;
                                    heapClassInst.heapFloat[r10 + numDefine32] = f0;
                                    r11 = heapClassInst.heap32[r10 + numDefine27];
                                    r10 = heapClassInst.heap32[r10 + numDefine26];
                                    heapClassInst.heap32[g0] = r10;
                                    heapClassInst.heap32[g0 + 1] = r11;
                                    heapClassInst.heap32[g0 + numDefine2] = r9;
                                    zn35btSequentialImpulseConstraintSolver33resolveSingleConstraintRowGenericER11btRigidBodyS1RK18btSolverConstraint(i7);
                                }
                                r8 = (r8 + 1) | 0;
                                if (r7 == r8) {
                                    break repeat33;
                                } else {
                                    continue repeat51;
                                }
                            }
                        }
                    } else {
                        repeat57:
                        do {
                            if (!(r8 < 1)) {
                                r8 = 0;
                                r7 = r8;
                                while (true) {
                                    r9 = (r7 * numDefine34) | 0;
                                    r10 = heapClassInst.heap32[r6 + numDefine9];
                                    r9 = r9 << numDefine2;
                                    r9 = (r10 + r9) | 0;
                                    r9 = r9 >> numDefine2;
                                    r11 = heapClassInst.heap32[r9 + numDefine27];
                                    r9 = heapClassInst.heap32[r9 + numDefine26];
                                    r10 = (r10 + r8) | 0;
                                    heapClassInst.heap32[g0] = r9;
                                    heapClassInst.heap32[g0 + 1] = r11;
                                    heapClassInst.heap32[g0 + numDefine2] = r10;
                                    r7 = (r7 + 1) | 0;
                                    r8 = (r8 + numDefine136) | 0;
                                    zn35btSequentialImpulseConstraintSolver33resolveSingleConstraintRowGenericER11btRigidBodyS1RK18btSolverConstraint(i7);
                                    r9 = heapClassInst.heap32[r6 + numDefine7];
                                    if (!(r9 > r7)) {
                                        break repeat57;
                                    }
                                }
                            }
                        } while (false);
                        repeat62:
                        do {
                            if (!(r3 < 1)) {
                                r7 = r2;
                                r8 = r3;
                                while (true) {
                                    r9 = r7 >> numDefine2;
                                    r9 = heapClassInst.heap32[r9];
                                    r10 = r9 >> numDefine2;
                                    r11 = heapClassInst.heap32[r10];
                                    r11 = r11 >> numDefine2;
                                    r11 = heapClassInst.heap32[r11 + numDefine6];
                                    f0 = heapClassInst.heapFloat[r4 + numDefine3];
                                    r12 = heapClassInst.heap32[r10 + numDefine6];
                                    r10 = heapClassInst.heap32[r10 + numDefine5];
                                    heapClassInst.heap32[g0] = r9;
                                    heapClassInst.heap32[g0 + 1] = r10;
                                    heapClassInst.heap32[g0 + numDefine2] = r12;
                                    heapClassInst.heapFloat[g0 + numDefine3] = f0;
                                    r8 = (r8 + -1) | 0;
                                    r7 = (r7 + numDefine4) | 0;
                                    functionTable.get(r11 >> numDefine2).accept(i7);
                                    if (!(r8 != 0)) {
                                        break repeat62;
                                    }
                                }
                            }
                        } while (false);
                        r7 = heapClassInst.heap32[r6 + numDefine2];
                        repeat67:
                        do {
                            if (!(r7 < 1)) {
                                r8 = 0;
                                while (true) {
                                    r9 = heapClassInst.heap32[r6 + numDefine19];
                                    r10 = r8 << numDefine2;
                                    r9 = (r9 + r10) | 0;
                                    r9 = r9 >> numDefine2;
                                    r9 = heapClassInst.heap32[r9];
                                    r9 = (r9 * numDefine136) | 0;
                                    r10 = heapClassInst.heap32[r6 + numDefine4];
                                    r9 = (r10 + r9) | 0;
                                    r10 = r9 >> numDefine2;
                                    r11 = heapClassInst.heap32[r10 + numDefine27];
                                    r10 = heapClassInst.heap32[r10 + numDefine26];
                                    heapClassInst.heap32[g0] = r10;
                                    heapClassInst.heap32[g0 + 1] = r11;
                                    heapClassInst.heap32[g0 + numDefine2] = r9;
                                    r8 = (r8 + 1) | 0;
                                    zn35btSequentialImpulseConstraintSolver36resolveSingleConstraintRowLowerLimitER11btRigidBodyS1RK18btSolverConstraint(i7);
                                    if (!(r7 != r8)) {
                                        break repeat67;
                                    }
                                }
                            }
                        } while (false);
                        r7 = heapClassInst.heap32[r6 + numDefine12];
                        if (!(r7 < 1)) {
                            r8 = 0;
                            while (true) {
                                r9 = heapClassInst.heap32[r6 + numDefine24];
                                r10 = r8 << numDefine2;
                                r9 = (r9 + r10) | 0;
                                r9 = r9 >> numDefine2;
                                r9 = heapClassInst.heap32[r9];
                                r10 = heapClassInst.heap32[r6 + numDefine14];
                                r9 = (r9 * numDefine136) | 0;
                                r9 = (r10 + r9) | 0;
                                r10 = r9 >> numDefine2;
                                r11 = heapClassInst.heap32[r10 + numDefine25];
                                r12 = heapClassInst.heap32[r6 + numDefine4];
                                r11 = (r11 * numDefine136) | 0;
                                r11 = (r12 + r11) | 0;
                                r11 = r11 >> numDefine2;
                                f0 = heapClassInst.heapFloat[r11 + numDefine21];
                                f1 = 0;
                                if (!(f0 <= f1)) {
                                    f1 = heapClassInst.heapFloat[r10 + numDefine22];
                                    f0 = f1 * f0;
                                    f1 = -f0;
                                    heapClassInst.heapFloat[r10 + numDefine31] = f1;
                                    heapClassInst.heapFloat[r10 + numDefine32] = f0;
                                    r11 = heapClassInst.heap32[r10 + numDefine27];
                                    r10 = heapClassInst.heap32[r10 + numDefine26];
                                    heapClassInst.heap32[g0] = r10;
                                    heapClassInst.heap32[g0 + 1] = r11;
                                    heapClassInst.heap32[g0 + numDefine2] = r9;
                                    zn35btSequentialImpulseConstraintSolver33resolveSingleConstraintRowGenericER11btRigidBodyS1RK18btSolverConstraint(i7);
                                }
                                r8 = (r8 + 1) | 0;
                                if (!(r7 != r8)) {
                                    break repeat33;
                                }
                            }
                        }
                    }
                } while (false);
                r5 = (r5 + 1) | 0;
                r6 = heapClassInst.heap32[r4 + numDefine5];
                if (r6 > r5) {
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
        }
        r4 = heapClassInst.heap32[fp + 1];
        r5 = heapClassInst.heap32[fp + numDefine2];
        r6 = heapClassInst.heap32[fp + numDefine3];
        r7 = heapClassInst.heap32[fp + numDefine4];
        r8 = heapClassInst.heap32[fp + numDefine8];
        r9 = heapClassInst.heap32[fp + numDefine9];
        r10 = r0 >> numDefine2;
        r10 = heapClassInst.heap32[r10];
        r10 = r10 >> numDefine2;
        r10 = heapClassInst.heap32[r10 + numDefine6];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r4;
        heapClassInst.heap32[g0 + numDefine2] = r5;
        heapClassInst.heap32[g0 + numDefine3] = r6;
        heapClassInst.heap32[g0 + numDefine4] = r7;
        heapClassInst.heap32[g0 + numDefine5] = r2;
        heapClassInst.heap32[g0 + numDefine6] = r3;
        heapClassInst.heap32[g0 + numDefine7] = r1;
        heapClassInst.heap32[g0 + numDefine8] = r8;
        heapClassInst.heap32[g0 + numDefine9] = r9;
        r0 = zn15CProfileManager11CurrentNodeE;
        functionTable.get(r10 >> numDefine2).accept(i7);
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        r2 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + numDefine4];
        r3 = (r3 + -1) | 0;
        heapClassInst.heap32[r2 + numDefine4] = r3;
        repeat80:
        do {
            if (!(r3 != 0)) {
                r3 = heapClassInst.heap32[r2 + 1];
                if (r3 != 0) {
                    r1 = sp + numDefineNeg8;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r3 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r1 = r1 >> numDefine2;
                    r4 = heapClassInst.heap32[fp + numDefineNeg2];
                    r5 = heapClassInst.heap32[r3];
                    r4 = (r4 - r5) | 0;
                    r1 = heapClassInst.heap32[r1 + 1];
                    r3 = heapClassInst.heap32[r3 + 1];
                    r1 = (r1 - r3) | 0;
                    r3 = (int) ((r4 * numDefineN6) | 0);
                    r1 = (r1 + r3) | 0;
                    r3 = heapClassInst.heap32[r2 + numDefine3];
                    r1 = (r1 - r3) | 0;
                    f0 = uint(r1);
                    f1 = numDefine1000;
                    f2 = heapClassInst.heapFloat[r2 + numDefine2];
                    f0 = f0 / f1;
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r2 + numDefine2] = f0;
                    r1 = heapClassInst.heap32[r2 + numDefine4];
                    if (r1 != 0) {
                        break repeat80;
                    } else {
                        r1 = heapClassInst.heap32[r0];
                    }
                }
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1 + numDefine5];
                heapClassInst.heap32[r0] = r1;
            }
        } while (false);
        f0 = 0;
        commonVariable.fg0 = f0;
        
    }

    static void zn35btSVector3P11(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg288;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine13];
        r3 = heapClassInst.heap32[r1 + numDefine12];
        r4 = heapClassInst.heap32[fp + 1];
        r5 = heapClassInst.heap32[fp + numDefine2];
        r6 = heapClassInst.heap32[fp + numDefine3];
        r7 = heapClassInst.heap32[fp + numDefine4];
        r8 = heapClassInst.heap32[fp + numDefine5];
        r9 = heapClassInst.heap32[fp + numDefine6];
        r10 = heapClassInst.heap32[fp + numDefine7];
        f0 = heapClassInst.heapFloat[fp + numDefine8];
        f1 = heapClassInst.heapFloat[fp + numDefine9];
        f2 = heapClassInst.heapFloat[fp + numDefine10];
        if (r2 == r3) {
            r11 = 1;
            r12 = r3 << 1;
            r12 = r3 == 0 ? r11 : r12;
            if (r2 >= r12) {
                label = 1;
            } else {
                if (r12 != 0) {
                    r2 = gNumAlignedAllocs;
                    r2 = r2 >> numDefine2;
                    r13 = heapClassInst.heap32[r2];
                    r14 = (r12 * numDefine136) | 0;
                    r13 = (r13 + 1) | 0;
                    r14 = r14 | numDefine3;
                    heapClassInst.heap32[r2] = r13;
                    r2 = (r14 + numDefine16) | 0;
                    heapClassInst.heap32[g0] = r2;
                    mallocNew(i7);
                    r13 = commonVariable.rg0;
                    if (r13 != 0) {
                        r2 = 0;
                        r14 = (r13 + numDefine4) | 0;
                        r2 = (r2 - r14) | 0;
                        r2 = r2 & numDefine15;
                        r2 = (r13 + r2) | 0;
                        r14 = (r2 + numDefine4) | 0;
                        r2 = r2 >> numDefine2;
                        heapClassInst.heap32[r2] = r13;
                        r13 = r14;
                    }
                } else {
                    r13 = 0;
                }
                r14 = (r0 + numDefine56) | 0;
                if (r3 < 1) {
                    r2 = r14 >> numDefine2;
                    r16 = heapClassInst.heap32[r2];
                } else {
                    r2 = 0;
                    r15 = r3;
                    repeat12:
                    while (true) {
                        r16 = r14 >> numDefine2;
                        r16 = heapClassInst.heap32[r16];
                        r17 = (r13 + r2) | 0;
                        r18 = (r16 + r2) | 0;
                        heapClassInst.heap32[g0] = r17;
                        heapClassInst.heap32[g0 + 1] = r18;
                        heapClassInst.heap32[g0 + numDefine2] = numDefine136;
                        r15 = (r15 + -1) | 0;
                        r2 = (r2 + numDefine136) | 0;
                        memcpy(i7);
                        if (!(r15 != 0)) {
                            break repeat12;
                        }
                    }
                    r14 = (r0 + numDefine56) | 0;
                }
                if (r16 != 0) {
                    r2 = heapClassInst.heapU8[r0 + numDefine60];
                    if (r2 != 0) {
                        r2 = gNumAlignedFree;
                        r2 = r2 >> numDefine2;
                        r15 = heapClassInst.heap32[r2];
                        r15 = (r15 + 1) | 0;
                        r16 = r16 >> numDefine2;
                        heapClassInst.heap32[r2] = r15;
                        r2 = heapClassInst.heap32[r16 + -1];
                        heapClassInst.heap32[g0] = r2;
                        free(i7);
                        r2 = heapClassInst.heap32[r1 + numDefine12];
                    } else {
                        r2 = r3;
                    }
                    r15 = r14 >> numDefine2;
                    heapClassInst.heap32[r15] = 0;
                } else {
                    r2 = r3;
                }
                r14 = r14 >> numDefine2;
                heapClassInst.heap8[r0 + numDefine60] = (byte) r11;
                heapClassInst.heap32[r14] = r13;
                heapClassInst.heap32[r1 + numDefine13] = r12;
                label = numDefine19;
            }
        } else {
            label = 1;
        }
        if (label == 1) {
            r2 = r3;
        }
        r0 = (r2 + 1) | 0;
        heapClassInst.heap32[r1 + numDefine12] = r0;
        r0 = heapClassInst.heap32[r1 + numDefine14];
        r1 = (r3 * numDefine136) | 0;
        r0 = (r0 + r1) | 0;
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r0 + numDefine25] = r5;
        r1 = heapClassInst.heapU8[r9 + numDefine232];
        r1 = r1 & numDefine2;
        if (!(r1 != 0)) {
            r9 = 0;
        }
        r1 = heapClassInst.heapU8[r10 + numDefine232];
        r1 = r1 & numDefine2;
        if (!(r1 != 0)) {
            r10 = 0;
        }
        r1 = r4 >> numDefine2;
        heapClassInst.heap32[r0 + numDefine4] = heapClassInst.heap32[r1];
        heapClassInst.heap32[r0 + numDefine5] = heapClassInst.heap32[r1 + 1];
        heapClassInst.heap32[r0 + numDefine6] = heapClassInst.heap32[r1 + numDefine2];
        heapClassInst.heap32[r0 + numDefine7] = heapClassInst.heap32[r1 + numDefine3];
        if (r9 == 0) {
            r2 = zgvzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
            r3 = heapClassInst.heapU8[r2];
            if (!(r3 != 0)) {
                r3 = zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
                r4 = r3 >> numDefine2;
                heapClassInst.heap32[r4 + numDefine41] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine42] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine43] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine44] = 0;
                heapClassInst.heap32[r4 + numDefine45] = 0;
                heapClassInst.heap32[r4 + numDefine46] = (int) numDefine44395;
                heapClassInst.heap32[r4 + numDefine47] = 0;
                heapClassInst.heap32[r4 + numDefine48] = 0;
                heapClassInst.heap32[r4 + numDefine49] = 0;
                heapClassInst.heap32[r4 + numDefine50] = 0;
                heapClassInst.heap32[r4 + numDefine51] = 1;
                heapClassInst.heap32[r4 + numDefine52] = -1;
                heapClassInst.heap32[r4 + numDefine53] = -1;
                heapClassInst.heap32[r4 + numDefine54] = 1;
                heapClassInst.heap32[r4 + numDefine55] = 0;
                heapClassInst.heap32[r4 + numDefine56] = (int) numDefine64608;
                heapClassInst.heap32[r4 + numDefine57] = 0;
                heapClassInst.heap32[r4 + numDefine58] = 1;
                heapClassInst.heap32[r4 + numDefine59] = 0;
                heapClassInst.heap32[r4 + numDefine60] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine61] = 0;
                heapClassInst.heap32[r4 + numDefine62] = 0;
                heapClassInst.heap32[r4 + numDefine63] = 0;
                heapClassInst.heap32[r4 + 1] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine2] = 0;
                heapClassInst.heap32[r4 + numDefine3] = 0;
                heapClassInst.heap32[r4 + numDefine4] = 0;
                heapClassInst.heap32[r4 + numDefine5] = 0;
                heapClassInst.heap32[r4 + numDefine6] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine7] = 0;
                heapClassInst.heap32[r4 + numDefine8] = 0;
                heapClassInst.heap32[r4 + numDefine9] = 0;
                heapClassInst.heap32[r4 + numDefine10] = 0;
                heapClassInst.heap32[r4 + numDefine11] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine12] = 0;
                heapClassInst.heap32[r4 + numDefine13] = 0;
                heapClassInst.heap32[r4 + numDefine14] = 0;
                r5 = ztv11btRigidBody;
                heapClassInst.heap32[r4 + numDefine15] = 0;
                r5 = (r5 + numDefine8) | 0;
                heapClassInst.heap32[r4 + numDefine16] = 0;
                r11 = 1;
                heapClassInst.heap32[r4] = r5;
                heapClassInst.heap8[r3 + numDefine492] = (byte) r11;
                heapClassInst.heap32[r4 + numDefine122] = 0;
                heapClassInst.heap32[r4 + numDefine120] = 0;
                r5 = sp + numDefineNeg272;
                heapClassInst.heap32[r4 + numDefine121] = 0;
                r4 = r5 >> numDefine2;
                heapClassInst.heap32[fp + numDefineNeg68] = 0;
                heapClassInst.heap32[r4 + 1] = 0;
                heapClassInst.heap32[r4 + numDefine18] = 0;
                heapClassInst.heap32[r4 + numDefine19] = 0;
                heapClassInst.heap32[r4 + numDefine20] = 0;
                heapClassInst.heap32[r4 + numDefine21] = 0;
                heapClassInst.heap32[r4 + numDefine22] = 0;
                heapClassInst.heap32[r4 + numDefine23] = 0;
                heapClassInst.heap32[r4 + numDefine24] = 0;
                heapClassInst.heap32[r4 + numDefine25] = (int) numDefine64608;
                heapClassInst.heap32[r4 + numDefine26] = 0;
                heapClassInst.heap32[r4 + numDefine27] = (int) numDefine97773;
                r12 = 0;
                heapClassInst.heap32[r4 + numDefine28] = (int) numDefine53216;
                heapClassInst.heap8[sp + numDefineNeg156] = (byte) r12;
                heapClassInst.heap32[r4 + numDefine30] = (int) numDefine93162;
                heapClassInst.heap32[r4 + numDefine31] = (int) numDefine81770;
                heapClassInst.heap32[r4 + numDefine32] = (int) numDefine81770;
                heapClassInst.heap32[r4 + numDefine33] = (int) numDefine81770;
                heapClassInst.heap32[r4 + numDefine2] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine3] = 0;
                heapClassInst.heap32[r4 + numDefine4] = 0;
                heapClassInst.heap32[r4 + numDefine5] = 0;
                heapClassInst.heap32[r4 + numDefine6] = 0;
                heapClassInst.heap32[r4 + numDefine7] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine8] = 0;
                heapClassInst.heap32[r4 + numDefine9] = 0;
                heapClassInst.heap32[r4 + numDefine10] = 0;
                heapClassInst.heap32[r4 + numDefine11] = 0;
                heapClassInst.heap32[r4 + numDefine12] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine13] = 0;
                heapClassInst.heap32[r4 + numDefine14] = 0;
                heapClassInst.heap32[r4 + numDefine15] = 0;
                heapClassInst.heap32[r4 + numDefine16] = 0;
                heapClassInst.heap32[r4 + numDefine17] = 0;
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r5;
                zn11btRigidBody14setupRigidBodyERKNS27btRigidBodyConstructionInfoE(i7);
                heapClassInst.heap8[r2] = (byte) r11;
            }
            r2 = zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
            r3 = r2 >> numDefine2;
            r4 = heapClassInst.heap32[r3 + numDefine51];
            r4 = r4 | 1;
            heapClassInst.heap32[r3 + numDefine51] = r4;
            heapClassInst.heap32[r3 + numDefine84] = 0;
            f3 = 0;
            f4 = heapClassInst.heapFloat[r3 + numDefine95];
            f5 = heapClassInst.heapFloat[r3 + numDefine94];
            f6 = heapClassInst.heapFloat[r3 + numDefine93];
            f6 = f6 * f3;
            f5 = f5 * f3;
            heapClassInst.heapFloat[r3 + numDefine89] = f6;
            f4 = f4 * f3;
            heapClassInst.heapFloat[r3 + numDefine90] = f5;
            heapClassInst.heapFloat[r3 + numDefine91] = f4;
            heapClassInst.heap32[r3 + numDefine92] = 0;
            heapClassInst.heap32[r3 + numDefine97] = 0;
            heapClassInst.heap32[r3 + numDefine98] = 0;
            heapClassInst.heap32[r3 + numDefine99] = 0;
            heapClassInst.heap32[r3 + numDefine100] = 0;
            f4 = heapClassInst.heapFloat[r3 + numDefine87];
            f5 = heapClassInst.heapFloat[r3 + numDefine86];
            f6 = heapClassInst.heapFloat[r3 + numDefine85];
            f6 = f6 * f3;
            f5 = f5 * f3;
            heapClassInst.heapFloat[r3 + numDefine138] = f6;
            f3 = f4 * f3;
            heapClassInst.heapFloat[r3 + numDefine139] = f5;
            heapClassInst.heapFloat[r3 + numDefine140] = f3;
            heapClassInst.heap32[r3 + numDefine141] = 0;
        } else {
            r2 = r9;
        }
        heapClassInst.heap32[r0 + numDefine26] = r2;
        if (r10 == 0) {
            r2 = zgvzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
            r3 = heapClassInst.heapU8[r2];
            if (!(r3 != 0)) {
                r3 = zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
                r4 = r3 >> numDefine2;
                heapClassInst.heap32[r4 + numDefine41] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine42] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine43] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine44] = 0;
                heapClassInst.heap32[r4 + numDefine45] = 0;
                heapClassInst.heap32[r4 + numDefine46] = (int) numDefine44395;
                heapClassInst.heap32[r4 + numDefine47] = 0;
                heapClassInst.heap32[r4 + numDefine48] = 0;
                heapClassInst.heap32[r4 + numDefine49] = 0;
                heapClassInst.heap32[r4 + numDefine50] = 0;
                heapClassInst.heap32[r4 + numDefine51] = 1;
                heapClassInst.heap32[r4 + numDefine52] = -1;
                heapClassInst.heap32[r4 + numDefine53] = -1;
                heapClassInst.heap32[r4 + numDefine54] = 1;
                heapClassInst.heap32[r4 + numDefine55] = 0;
                heapClassInst.heap32[r4 + numDefine56] = (int) numDefine64608;
                heapClassInst.heap32[r4 + numDefine57] = 0;
                heapClassInst.heap32[r4 + numDefine58] = 1;
                heapClassInst.heap32[r4 + numDefine59] = 0;
                heapClassInst.heap32[r4 + numDefine60] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine61] = 0;
                heapClassInst.heap32[r4 + numDefine62] = 0;
                heapClassInst.heap32[r4 + numDefine63] = 0;
                heapClassInst.heap32[r4 + 1] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine2] = 0;
                heapClassInst.heap32[r4 + numDefine3] = 0;
                heapClassInst.heap32[r4 + numDefine4] = 0;
                heapClassInst.heap32[r4 + numDefine5] = 0;
                heapClassInst.heap32[r4 + numDefine6] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine7] = 0;
                heapClassInst.heap32[r4 + numDefine8] = 0;
                heapClassInst.heap32[r4 + numDefine9] = 0;
                heapClassInst.heap32[r4 + numDefine10] = 0;
                heapClassInst.heap32[r4 + numDefine11] = (int) numDefine53216;
                heapClassInst.heap32[r4 + numDefine12] = 0;
                heapClassInst.heap32[r4 + numDefine13] = 0;
                heapClassInst.heap32[r4 + numDefine14] = 0;
                r5 = ztv11btRigidBody;
                heapClassInst.heap32[r4 + numDefine15] = 0;
                r5 = (r5 + numDefine8) | 0;
                heapClassInst.heap32[r4 + numDefine16] = 0;
                r11 = 1;
                heapClassInst.heap32[r4] = r5;
                heapClassInst.heap8[r3 + numDefine492] = (byte) r11;
                heapClassInst.heap32[r4 + numDefine122] = 0;
                heapClassInst.heap32[r4 + numDefine120] = 0;
                r5 = sp + numDefineNeg136;
                heapClassInst.heap32[r4 + numDefine121] = 0;
                r4 = r5 >> numDefine2;
                heapClassInst.heap32[fp + numDefineNeg34] = 0;
                heapClassInst.heap32[r4 + 1] = 0;
                heapClassInst.heap32[r4 + numDefine18] = 0;
                heapClassInst.heap32[r4 + numDefine19] = 0;
                heapClassInst.heap32[r4 + numDefine20] = 0;
                heapClassInst.heap32[r4 + numDefine21] = 0;
                heapClassInst.heap32[r4 + numDefine22] = 0;
                heapClassInst.heap32[r4 + numDefine23] = 0;
                heapClassInst.heap32[r4 + numDefine24] = 0;
                heapClassInst.heap32[r4 + numDefine25] = numDefine64608;
                heapClassInst.heap32[r4 + numDefine26] = 0;
                heapClassInst.heap32[r4 + numDefine27] = numDefine97773;
                r12 = 0;
                heapClassInst.heap32[r4 + numDefine28] = numDefine53216;
                heapClassInst.heap8[sp + numDefineNeg20] = (byte) r12;
                heapClassInst.heap32[r4 + numDefine30] = numDefine93162;
                heapClassInst.heap32[r4 + numDefine31] = numDefine81770;
                heapClassInst.heap32[r4 + numDefine32] = numDefine81770;
                heapClassInst.heap32[r4 + numDefine33] = numDefine81770;
                heapClassInst.heap32[r4 + numDefine2] = numDefine53216;
                heapClassInst.heap32[r4 + numDefine3] = 0;
                heapClassInst.heap32[r4 + numDefine4] = 0;
                heapClassInst.heap32[r4 + numDefine5] = 0;
                heapClassInst.heap32[r4 + numDefine6] = 0;
                heapClassInst.heap32[r4 + numDefine7] = numDefine53216;
                heapClassInst.heap32[r4 + numDefine8] = 0;
                heapClassInst.heap32[r4 + numDefine9] = 0;
                heapClassInst.heap32[r4 + numDefine10] = 0;
                heapClassInst.heap32[r4 + numDefine11] = 0;
                heapClassInst.heap32[r4 + numDefine12] = numDefine53216;
                heapClassInst.heap32[r4 + numDefine13] = 0;
                heapClassInst.heap32[r4 + numDefine14] = 0;
                heapClassInst.heap32[r4 + numDefine15] = 0;
                heapClassInst.heap32[r4 + numDefine16] = 0;
                heapClassInst.heap32[r4 + numDefine17] = 0;
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r5;
                zn11btRigidBody14setupRigidBodyERKNS27btRigidBodyConstructionInfoE(i7);
                heapClassInst.heap8[r2] = (byte) r11;
            }
            r2 = zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
            r3 = r2 >> numDefine2;
            r4 = heapClassInst.heap32[r3 + numDefine51];
            r4 = r4 | 1;
            heapClassInst.heap32[r3 + numDefine51] = r4;
            heapClassInst.heap32[r3 + numDefine84] = 0;
            f3 = 0;
            f4 = heapClassInst.heapFloat[r3 + numDefine95];
            f5 = heapClassInst.heapFloat[r3 + numDefine94];
            f6 = heapClassInst.heapFloat[r3 + numDefine93];
            f6 = f6 * f3;
            f5 = f5 * f3;
            heapClassInst.heapFloat[r3 + numDefine89] = f6;
            f4 = f4 * f3;
            heapClassInst.heapFloat[r3 + numDefine90] = f5;
            heapClassInst.heapFloat[r3 + numDefine91] = f4;
            heapClassInst.heap32[r3 + numDefine92] = 0;
            heapClassInst.heap32[r3 + numDefine97] = 0;
            heapClassInst.heap32[r3 + numDefine98] = 0;
            heapClassInst.heap32[r3 + numDefine99] = 0;
            heapClassInst.heap32[r3 + numDefine100] = 0;
            f4 = heapClassInst.heapFloat[r3 + numDefine87];
            f5 = heapClassInst.heapFloat[r3 + numDefine86];
            f6 = heapClassInst.heapFloat[r3 + numDefine85];
            f6 = f6 * f3;
            f5 = f5 * f3;
            heapClassInst.heapFloat[r3 + numDefine138] = f6;
            f3 = f4 * f3;
            heapClassInst.heapFloat[r3 + numDefine139] = f5;
            heapClassInst.heapFloat[r3 + numDefine140] = f3;
            heapClassInst.heap32[r3 + numDefine141] = 0;
        } else {
            r2 = r10;
        }
        r3 = r6 >> numDefine2;
        heapClassInst.heap32[r0 + numDefine27] = r2;
        heapClassInst.heap32[r0 + numDefine22] = heapClassInst.heap32[r3 + numDefine21];
        heapClassInst.heap32[r0 + numDefine28] = 0;
        heapClassInst.heap32[r0 + numDefine21] = 0;
        heapClassInst.heap32[r0 + numDefine20] = 0;
        r2 = r7 >> numDefine2;
        f3 = heapClassInst.heapFloat[r0 + numDefine5];
        f4 = heapClassInst.heapFloat[r2 + numDefine2];
        f5 = heapClassInst.heapFloat[r0 + numDefine6];
        f6 = heapClassInst.heapFloat[r2 + 1];
        f7 = heapClassInst.heapFloat[r0 + numDefine4];
        f8 = heapClassInst.heapFloat[r2];
        f9 = f6 * f5;
        f10 = f4 * f3;
        f9 = f9 - f10;
        f4 = f4 * f7;
        f10 = f8 * f5;
        f4 = f4 - f10;
        heapClassInst.heapFloat[r0] = f9;
        f8 = f8 * f3;
        f6 = f6 * f7;
        f6 = f8 - f6;
        heapClassInst.heapFloat[r0 + 1] = f4;
        heapClassInst.heapFloat[r0 + numDefine2] = f6;
        heapClassInst.heap32[r0 + numDefine3] = 0;
        if (r9 == 0) {
            heapClassInst.heap32[r0 + numDefine12] = 0;
            heapClassInst.heap32[r0 + numDefine13] = 0;
            f10 = 0;
            heapClassInst.heap32[r0 + numDefine14] = 0;
            heapClassInst.heap32[r0 + numDefine15] = 0;
            f11 = f10;
            f8 = f10;
        } else {
            r3 = r9 >> numDefine2;
            f8 = heapClassInst.heapFloat[r3 + numDefine64];
            f10 = heapClassInst.heapFloat[r3 + numDefine65];
            f11 = heapClassInst.heapFloat[r3 + numDefine68];
            f12 = heapClassInst.heapFloat[r3 + numDefine69];
            f8 = f8 * f9;
            f10 = f10 * f4;
            f13 = heapClassInst.heapFloat[r3 + numDefine66];
            f14 = heapClassInst.heapFloat[r3 + numDefine72];
            f15 = heapClassInst.heapFloat[r3 + numDefine73];
            f16 = heapClassInst.heapFloat[r3 + numDefine70];
            f11 = f11 * f9;
            f12 = f12 * f4;
            f8 = f8 + f10;
            f10 = f13 * f6;
            f13 = heapClassInst.heapFloat[r3 + numDefine74];
            f14 = f14 * f9;
            f15 = f15 * f4;
            f11 = f11 + f12;
            f12 = f16 * f6;
            f8 = f8 + f10;
            f10 = heapClassInst.heapFloat[r3 + numDefine134];
            f16 = heapClassInst.heapFloat[r3 + numDefine136];
            f17 = heapClassInst.heapFloat[r3 + numDefine135];
            f11 = f11 + f12;
            f8 = f8 * f10;
            f10 = f14 + f15;
            f12 = f13 * f6;
            f10 = f10 + f12;
            f11 = f11 * f17;
            heapClassInst.heapFloat[r0 + numDefine12] = f8;
            f10 = f10 * f16;
            heapClassInst.heapFloat[r0 + numDefine13] = f11;
            heapClassInst.heapFloat[r0 + numDefine14] = f10;
            heapClassInst.heap32[r0 + numDefine15] = 0;
        }
        r3 = r8 >> numDefine2;
        f12 = heapClassInst.heapFloat[r3 + numDefine2];
        f13 = heapClassInst.heapFloat[r3 + 1];
        f14 = heapClassInst.heapFloat[r3];
        f15 = f12 * f3;
        f16 = f13 * f5;
        f15 = f15 - f16;
        f16 = f14 * f5;
        f12 = f12 * f7;
        f12 = f16 - f12;
        heapClassInst.heapFloat[r0 + numDefine8] = f15;
        f13 = f13 * f7;
        f14 = f14 * f3;
        f13 = f13 - f14;
        heapClassInst.heapFloat[r0 + numDefine9] = f12;
        heapClassInst.heapFloat[r0 + numDefine10] = f13;
        heapClassInst.heap32[r0 + numDefine11] = 0;
        if (r10 == 0) {
            heapClassInst.heap32[r0 + numDefine16] = 0;
            heapClassInst.heap32[r0 + numDefine17] = 0;
            f14 = 0;
            heapClassInst.heap32[r0 + numDefine18] = 0;
            heapClassInst.heap32[r0 + numDefine19] = 0;
            f17 = f14;
            f16 = f14;
        } else {
            r4 = r10 >> numDefine2;
            f14 = heapClassInst.heapFloat[r4 + numDefine64];
            f16 = heapClassInst.heapFloat[r4 + numDefine65];
            f17 = heapClassInst.heapFloat[r4 + numDefine68];
            f18 = heapClassInst.heapFloat[r4 + numDefine69];
            f14 = f14 * f15;
            f16 = f16 * f12;
            f19 = heapClassInst.heapFloat[r4 + numDefine66];
            f20 = heapClassInst.heapFloat[r4 + numDefine72];
            f21 = heapClassInst.heapFloat[r4 + numDefine73];
            f22 = heapClassInst.heapFloat[r4 + numDefine70];
            f17 = f17 * f15;
            f18 = f18 * f12;
            f14 = f14 + f16;
            f16 = f19 * f13;
            f19 = heapClassInst.heapFloat[r4 + numDefine74];
            f20 = f20 * f15;
            f21 = f21 * f12;
            f17 = f17 + f18;
            f18 = f22 * f13;
            f14 = f14 + f16;
            f16 = heapClassInst.heapFloat[r4 + numDefine134];
            f22 = heapClassInst.heapFloat[r4 + numDefine136];
            f23 = heapClassInst.heapFloat[r4 + numDefine135];
            f17 = f17 + f18;
            f14 = f14 * f16;
            f16 = f20 + f21;
            f18 = f19 * f13;
            f16 = f16 + f18;
            f17 = f17 * f23;
            heapClassInst.heapFloat[r0 + numDefine16] = f14;
            f16 = f16 * f22;
            heapClassInst.heapFloat[r0 + numDefine17] = f17;
            heapClassInst.heapFloat[r0 + numDefine18] = f16;
            heapClassInst.heap32[r0 + numDefine19] = 0;
        }
        if (r9 != 0) {
            f18 = heapClassInst.heapFloat[r2 + 1];
            f19 = heapClassInst.heapFloat[r2 + numDefine2];
            f20 = heapClassInst.heapFloat[r2];
            f21 = f11 * f19;
            f22 = f10 * f18;
            f10 = f10 * f20;
            f19 = f8 * f19;
            f23 = heapClassInst.heapFloat[r1];
            f21 = f21 - f22;
            f22 = heapClassInst.heapFloat[r1 + 1];
            f10 = f10 - f19;
            f8 = f8 * f18;
            f11 = f11 * f20;
            f18 = f23 * f21;
            f10 = f22 * f10;
            f19 = heapClassInst.heapFloat[r1 + numDefine2];
            f8 = f8 - f11;
            r2 = r9 >> numDefine2;
            f10 = f18 + f10;
            f8 = f19 * f8;
            f11 = heapClassInst.heapFloat[r2 + numDefine84];
            f8 = f10 + f8;
            f8 = f11 + f8;
        } else {
            f8 = 0;
        }
        if (r10 != 0) {
            f10 = heapClassInst.heapFloat[r3 + numDefine2];
            f11 = heapClassInst.heapFloat[r3];
            f18 = heapClassInst.heapFloat[r3 + 1];
            f19 = f18 * f16;
            f20 = f10 * f17;
            f10 = f10 * f14;
            f16 = f11 * f16;
            f21 = heapClassInst.heapFloat[r1];
            f19 = f19 - f20;
            f20 = heapClassInst.heapFloat[r1 + 1];
            f10 = f10 - f16;
            f11 = f11 * f17;
            f14 = f18 * f14;
            f16 = f21 * f19;
            f10 = f20 * f10;
            f17 = heapClassInst.heapFloat[r1 + numDefine2];
            f14 = f11 - f14;
            r1 = r10 >> numDefine2;
            f10 = f16 + f10;
            f14 = f17 * f14;
            f11 = heapClassInst.heapFloat[r1 + numDefine84];
            f14 = f10 + f14;
            f14 = f11 + f14;
        } else {
            f14 = 0;
        }
        f8 = f8 + f14;
        f0 = f0 / f8;
        heapClassInst.heapFloat[r0 + numDefine23] = f0;
        if (r9 != 0) {
            r1 = r9 >> numDefine2;
            f8 = heapClassInst.heapFloat[r1 + numDefine76];
            f10 = heapClassInst.heapFloat[r1 + numDefine77];
            f8 = f7 * f8;
            f10 = f3 * f10;
            f11 = heapClassInst.heapFloat[r1 + numDefine78];
            f8 = f8 + f10;
            f10 = f5 * f11;
            f10 = f8 + f10;
            f14 = heapClassInst.heapFloat[r1 + numDefine80];
            f11 = heapClassInst.heapFloat[r1 + numDefine81];
            f8 = heapClassInst.heapFloat[r1 + numDefine82];
        } else {
            f8 = 0;
            f10 = f7 * f8;
            f11 = f3 * f8;
            f10 = f10 + f11;
            f11 = f5 * f8;
            f10 = f10 + f11;
            f11 = f8;
            f14 = f8;
        }
        f9 = f9 * f14;
        f4 = f4 * f11;
        f4 = f9 + f4;
        f6 = f6 * f8;
        f4 = f4 + f6;
        f4 = f10 + f4;
        if (r10 != 0) {
            r1 = r10 >> numDefine2;
            f6 = heapClassInst.heapFloat[r1 + numDefine80];
            f8 = heapClassInst.heapFloat[r1 + numDefine81];
            f6 = f15 * f6;
            f12 = f12 * f8;
            f15 = heapClassInst.heapFloat[r1 + numDefine82];
            f6 = f6 + f12;
            f12 = f13 * f15;
            f12 = f6 + f12;
            f15 = heapClassInst.heapFloat[r1 + numDefine76];
            f13 = heapClassInst.heapFloat[r1 + numDefine77];
            f6 = heapClassInst.heapFloat[r1 + numDefine78];
        } else {
            f6 = 0;
            f15 = f15 * f6;
            f12 = f12 * f6;
            f12 = f15 + f12;
            f13 = f13 * f6;
            f12 = f12 + f13;
            f13 = f6;
            f15 = f6;
        }
        f7 = f7 * f15;
        f3 = f3 * f13;
        f3 = f7 + f3;
        f5 = f5 * f6;
        f3 = f3 + f5;
        f3 = f12 - f3;
        f3 = f4 + f3;
        f1 = f1 - f3;
        f0 = f0 * f1;
        heapClassInst.heapFloat[r0 + numDefine29] = f0;
        heapClassInst.heapFloat[r0 + numDefine30] = f2;
        heapClassInst.heap32[r0 + numDefine31] = 0;
        heapClassInst.heap32[r0 + numDefine32] = (int) numDefine54297;
        return;
    }

    public static void zn23btDiscreteDynamicsWorld11setNumTasksEi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        
    }

    public static void zn23btDiscreteDynamicsWorld14updateVehiclesEf(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr289;
        r1 = heapClassInst.heap32[fp];
        heapClassInst.heap32[g0] = r0;
        r0 = r1 >> numDefine2;
        zn15CProfileManager13StartProfileEPKc(i7);
        r2 = heapClassInst.heap32[r0 + numDefine63];
        if (!(r2 < 1)) {
            f0 = heapClassInst.heapFloat[fp + 1];
            r2 = 0;
            repeat3:
            while (true) {
                r3 = heapClassInst.heap32[r0 + numDefine65];
                r4 = r2 << numDefine2;
                r3 = (r3 + r4) | 0;
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3];
                r4 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r4];
                r4 = r4 >> numDefine2;
                r4 = heapClassInst.heap32[r4 + numDefine2];
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heapFloat[g0 + numDefine2] = f0;
                r2 = (r2 + 1) | 0;
                functionTable.get(r4 >> numDefine2).accept(i7);
                r3 = heapClassInst.heap32[r0 + numDefine63];
                if (r3 > r2) {
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
        }
        r0 = zn15CProfileManager11CurrentNodeE;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        r2 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + numDefine4];
        r3 = (r3 + -1) | 0;
        heapClassInst.heap32[r2 + numDefine4] = r3;
        repeat6:
        do {
            if (!(r3 != 0)) {
                r3 = heapClassInst.heap32[r2 + 1];
                if (r3 != 0) {
                    r1 = sp + numDefineNeg8;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r3 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r1 = r1 >> numDefine2;
                    r4 = heapClassInst.heap32[fp + numDefineNeg2];
                    r5 = heapClassInst.heap32[r3];
                    r4 = (r4 - r5) | 0;
                    r1 = heapClassInst.heap32[r1 + 1];
                    r3 = heapClassInst.heap32[r3 + 1];
                    r1 = (r1 - r3) | 0;
                    r3 = (int) ((r4 * numDefineN6) | 0);
                    r1 = (r1 + r3) | 0;
                    r3 = heapClassInst.heap32[r2 + numDefine3];
                    r1 = (r1 - r3) | 0;
                    f0 = uint(r1);
                    f1 = numDefine1000;
                    f2 = heapClassInst.heapFloat[r2 + numDefine2];
                    f0 = f0 / f1;
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r2 + numDefine2] = f0;
                    r1 = heapClassInst.heap32[r2 + numDefine4];
                    if (r1 != 0) {
                        break repeat6;
                    } else {
                        r1 = heapClassInst.heap32[r0];
                    }
                }
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1 + numDefine5];
                heapClassInst.heap32[r0] = r1;
            }
        } while (false);
        
    }

    public static void zn15btDynamicsWorld13addConstraintEP17btTypedConstraintb(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        
    }

    public static void zn15btDynamicsWorld16removeConstraintEP17btTypedConstraint(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        
    }

    public static void znk15btDynamicsWorld17getNumConstraintsEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = 0;
        commonVariable.rg0 = r0;
        
    }

    public static void zn15btDynamicsWorld13getConstraintEi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = 0;
        commonVariable.rg0 = r0;
        
    }

    public static void znk15btDynamicsWorld13getConstraintEi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = 0;
        commonVariable.rg0 = r0;
        
    }

    public static void zn15btDynamicsWorld10addVehicleEP17btActionInterface(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        
    }

    public static void zn15btDynamicsWorld13removeVehicleEP17btActionInterface(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        
    }

    public static void zn15btDynamicsWorld12addCharacterEP17btActionInterface(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        
    }

    public static void zn15btDynamicsWorld15removeCharacterEP17btActionInterface(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        
    }

    public static void znk23btDiscreteDynamicsWorld12getWorldTypeEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = numDefine2;
        commonVariable.rg0 = r0;
        
    }

    public static void znk23btDiscreteDynamicsWorld10getGravityEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r0 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r0] = heapClassInst.heap32[r1 + numDefine56];
        heapClassInst.heap32[r0 + 1] = heapClassInst.heap32[r1 + numDefine57];
        heapClassInst.heap32[r0 + numDefine2] = heapClassInst.heap32[r1 + numDefine58];
        heapClassInst.heap32[r0 + numDefine3] = heapClassInst.heap32[r1 + numDefine59];
        
    }

    public static void zn23btDiscreteDynamicsWorld10addVehicleEP17btActionInterface(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r1];
        r1 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine15];
        r2 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r2;
        functionTable.get(r1 >> numDefine2).accept(i7);
        
    }

    public static void zn23btDiscreteDynamicsWorld13removeVehicleEP17btActionInterface(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r1];
        r1 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine16];
        r2 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r2;
        functionTable.get(r1 >> numDefine2).accept(i7);
        
    }

    public static void zn23btDiscreteDynamicsWorld12addCharacterEP17btActionInterface(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r1];
        r1 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine15];
        r2 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r2;
        functionTable.get(r1 >> numDefine2).accept(i7);
        
    }

    public static void zn23btDiscreteDynamicsWorld15removeCharacterEP17btActionInterface(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r1];
        r1 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine16];
        r2 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r2;
        functionTable.get(r1 >> numDefine2).accept(i7);
        
    }

    public static void zn34btClosestNotMeConvexResultCallbackD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztvn16btCollisionWorld27ClosestConvexResultCallbackE;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        
    }

    public static void zn34btClosestNotMeConvexResultCallbackD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztvn16btCollisionWorld27ClosestConvexResultCallbackE;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void znk34btClosestNotMeConvexResultCallback14needsCollisionEP17btBroadphaseProxy(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int label = 0;
        i7 = sp + numDefineNeg40;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = r1 >> numDefine2;
        r3 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r2];
        r4 = heapClassInst.heap32[r3 + numDefine20];
        if (r2 != r4) {
            r5 = heapClassInst.heapU16[(r0 + numDefine10) >> 1];
            r6 = heapClassInst.heapU16[(r1 + numDefine4) >> 1];
            r5 = r5 & r6;
            r5 = r5 & numDefine65535;
            if (r5 == 0) {
                label = 1;
            } else {
                r5 = heapClassInst.heapU16[(r1 + numDefine6) >> 1];
                r0 = heapClassInst.heapU16[(r0 + numDefine8) >> 1];
                r0 = r5 & r0;
                r0 = r0 & numDefine65535;
                if (r0 == 0) {
                    label = 1;
                } else {
                    r0 = heapClassInst.heap32[r3 + numDefine23];
                    r5 = r0 >> numDefine2;
                    r5 = heapClassInst.heap32[r5];
                    r5 = r5 >> numDefine2;
                    r5 = heapClassInst.heap32[r5 + numDefine7];
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r4;
                    heapClassInst.heap32[g0 + numDefine2] = r2;
                    functionTable.get(r5 >> numDefine2).accept(i7);
                    r0 = commonVariable.rg0;
                    if (r0 != 0) {
                        r0 = sp + numDefineNeg24;
                        r2 = 1;
                        r4 = r0 >> numDefine2;
                        heapClassInst.heap8[sp + numDefineNeg8] = (byte) r2;
                        heapClassInst.heap32[r4 + numDefine3] = 0;
                        heapClassInst.heap32[r4 + 1] = 0;
                        heapClassInst.heap32[r4 + numDefine2] = 0;
                        r5 = heapClassInst.heap32[r3 + numDefine22];
                        r6 = r5 >> numDefine2;
                        r6 = heapClassInst.heap32[r6];
                        r3 = heapClassInst.heap32[r3 + numDefine20];
                        r6 = r6 >> numDefine2;
                        r3 = r3 >> numDefine2;
                        r6 = heapClassInst.heap32[r6 + numDefine13];
                        r3 = heapClassInst.heap32[r3 + numDefine47];
                        heapClassInst.heap32[g0] = r5;
                        heapClassInst.heap32[g0 + 1] = r3;
                        heapClassInst.heap32[g0 + numDefine2] = r1;
                        functionTable.get(r6 >> numDefine2).accept(i7);
                        r1 = commonVariable.rg0;
                        repeat7:
                        do {
                            if (!(r1 == 0)) {
                                r1 = r1 >> numDefine2;
                                r3 = heapClassInst.heap32[r1 + numDefine2];
                                if (!(r3 == 0)) {
                                    r3 = heapClassInst.heap32[r4 + 1];
                                    if (!(r3 > -1)) {
                                        r5 = heapClassInst.heap32[r4 + numDefine2];
                                        if (r5 < 0) {
                                            r5 = heapClassInst.heap32[r4 + numDefine3];
                                            if (!(r5 == 0)) {
                                                r6 = heapClassInst.heapU8[sp + numDefineNeg8];
                                                if (!(r6 == 0)) {
                                                    r6 = gNumAlignedFree;
                                                    r6 = r6 >> numDefine2;
                                                    r7 = heapClassInst.heap32[r6];
                                                    r7 = (r7 + 1) | 0;
                                                    r5 = r5 >> numDefine2;
                                                    heapClassInst.heap32[r6] = r7;
                                                    r5 = heapClassInst.heap32[r5 + -1];
                                                    heapClassInst.heap32[g0] = r5;
                                                    free(i7);
                                                }
                                                heapClassInst.heap32[r4 + numDefine3] = 0;
                                            }
                                            heapClassInst.heap8[sp + numDefineNeg8] = (byte) r2;
                                            heapClassInst.heap32[r4 + numDefine3] = 0;
                                            heapClassInst.heap32[r4 + numDefine2] = 0;
                                        }
                                        repeat20:
                                        while (true) {
                                            r2 = r3 << numDefine2;
                                            r5 = heapClassInst.heap32[r4 + numDefine3];
                                            r2 = (r5 + r2) | 0;
                                            r3 = (r3 + 1) | 0;
                                            r2 = r2 >> numDefine2;
                                            heapClassInst.heap32[r2] = 0;
                                            if (!(r3 != 0)) {
                                                break repeat20;
                                            }
                                        }
                                    }
                                    heapClassInst.heap32[r4 + 1] = 0;
                                    r1 = heapClassInst.heap32[r1 + numDefine2];
                                    r2 = r1 >> numDefine2;
                                    r2 = heapClassInst.heap32[r2];
                                    r2 = r2 >> numDefine2;
                                    r2 = heapClassInst.heap32[r2 + numDefine4];
                                    heapClassInst.heap32[g0] = r1;
                                    heapClassInst.heap32[g0 + 1] = r0;
                                    functionTable.get(r2 >> numDefine2).accept(i7);
                                    r0 = heapClassInst.heap32[r4 + 1];
                                    r1 = 0;
                                    repeat23:
                                    while (true) {
                                        if (r0 > r1) {
                                            r2 = heapClassInst.heap32[r4 + numDefine3];
                                            r3 = r1 << numDefine2;
                                            r3 = (r2 + r3) | 0;
                                            r3 = r3 >> numDefine2;
                                            r3 = heapClassInst.heap32[r3];
                                            r3 = r3 >> numDefine2;
                                            r3 = heapClassInst.heap32[r3 + numDefine279];
                                            if (r3 > 0) {
                                                break repeat23;
                                            } else {
                                                r1 = (r1 + 1) | 0;
                                            }
                                        } else {
                                            break repeat7;
                                        }
                                    }
                                    if (!(r2 == 0)) {
                                        r0 = heapClassInst.heapU8[sp + numDefineNeg8];
                                        if (!(r0 == 0)) {
                                            r0 = gNumAlignedFree;
                                            r0 = r0 >> numDefine2;
                                            r1 = heapClassInst.heap32[r0];
                                            r1 = (r1 + 1) | 0;
                                            r2 = r2 >> numDefine2;
                                            heapClassInst.heap32[r0] = r1;
                                            r0 = heapClassInst.heap32[r2 + -1];
                                            heapClassInst.heap32[g0] = r0;
                                            free(i7);
                                        }
                                    }
                                    r0 = 0;
                                    commonVariable.rg0 = r0;
                                    
                                }
                            }
                        } while (false);
                        r0 = heapClassInst.heap32[r4 + numDefine3];
                        if (!(r0 == 0)) {
                            r2 = heapClassInst.heapU8[sp + numDefineNeg8];
                            if (!(r2 == 0)) {
                                r2 = gNumAlignedFree;
                                r2 = r2 >> numDefine2;
                                r1 = heapClassInst.heap32[r2];
                                r1 = (r1 + 1) | 0;
                                r0 = r0 >> numDefine2;
                                heapClassInst.heap32[r2] = r1;
                                r0 = heapClassInst.heap32[r0 + -1];
                                heapClassInst.heap32[g0] = r0;
                                free(i7);
                            }
                        }
                        r0 = 1;
                        commonVariable.rg0 = r0;
                        
                    } else {
                        r0 = 1;
                        label = numDefine28;
                    }
                }
            }
        } else {
            label = 1;
        }
        if (label == 1) {
            r0 = 0;
        }
        r0 = r0 & numDefine255;
        commonVariable.rg0 = r0;
        
    }

    public static void zn34btClosestNotMeConvexResultCallback15addSingleResultERN16btCollisionWorld17LocalConvexResultEb(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[fp];
        r3 = heapClassInst.heap32[r1];
        r4 = r2 >> numDefine2;
        r5 = heapClassInst.heap32[r4 + numDefine20];
        if (!(r3 == r5)) {
            r3 = heapClassInst.heapU8[r3 + numDefine204];
            r3 = r3 & numDefine4;
            if (!(r3 != 0)) {
                f0 = heapClassInst.heapFloat[r4 + numDefine7];
                f1 = heapClassInst.heapFloat[r4 + numDefine3];
                f2 = heapClassInst.heapFloat[r4 + numDefine8];
                f3 = heapClassInst.heapFloat[r4 + numDefine4];
                f4 = heapClassInst.heapFloat[r1 + numDefine2];
                f0 = f0 - f1;
                f1 = heapClassInst.heapFloat[r1 + numDefine3];
                f2 = f2 - f3;
                f3 = heapClassInst.heapFloat[r4 + numDefine9];
                f5 = heapClassInst.heapFloat[r4 + numDefine5];
                f0 = f4 * f0;
                f1 = f1 * f2;
                f2 = heapClassInst.heapFloat[r1 + numDefine4];
                f3 = f3 - f5;
                f4 = heapClassInst.heapFloat[r4 + numDefine21];
                f0 = f0 + f1;
                f1 = f2 * f3;
                f0 = f0 + f1;
                f1 = -f4;
                if (!(f0 >= f1)) {
                    r1 = heapClassInst.heap32[fp + numDefine2];
                    heapClassInst.heap32[g0] = r2;
                    heapClassInst.heap32[g0 + 1] = r0;
                    heapClassInst.heap32[g0 + numDefine2] = r1;
                    zn16btCollisionWorld27ClosestConvexResultCallback15addSingleResultERNS17LocalConvexResultEb(i7);

                    
                }
            }
        }
        f0 = 1;
        commonVariable.fg0 = f0;
        
    }

    public static void zn23btDiscreteDynamicsWorld19getConstraintSolverEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine44];
        commonVariable.rg0 = r0;
        
    }

    public static void znk23btDiscreteDynamicsWorld17getNumConstraintsEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine47];
        commonVariable.rg0 = r0;
        
    }

    public static void zn23btDiscreteDynamicsWorld13getConstraintEi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[fp + 1];
        r0 = heapClassInst.heap32[r0 + numDefine49];
        r1 = r1 << numDefine2;
        r0 = (r0 + r1) | 0;
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0];
        commonVariable.rg0 = r0;
        
    }

    public static void zn23btDiscreteDynamicsWorld11clearForcesEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + numDefine52];
        if (!(r1 < 1)) {
            r1 = 0;
            repeat3:
            while (true) {
                r2 = heapClassInst.heap32[r0 + numDefine54];
                r3 = r1 << numDefine2;
                r2 = (r2 + r3) | 0;
                r2 = r2 >> numDefine2;
                r2 = heapClassInst.heap32[r2];
                r2 = r2 >> numDefine2;
                r1 = (r1 + 1) | 0;
                heapClassInst.heap32[r2 + numDefine101] = 0;
                heapClassInst.heap32[r2 + numDefine102] = 0;
                heapClassInst.heap32[r2 + numDefine103] = 0;
                heapClassInst.heap32[r2 + numDefine104] = 0;
                heapClassInst.heap32[r2 + numDefine105] = 0;
                heapClassInst.heap32[r2 + numDefine106] = 0;
                heapClassInst.heap32[r2 + numDefine107] = 0;
                heapClassInst.heap32[r2 + numDefine108] = 0;
                r2 = heapClassInst.heap32[r0 + numDefine52];
                if (r2 > r1) {
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
        }
        
    }

    public static void znk23btDiscreteDynamicsWorld13getConstraintEi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[fp + 1];
        r0 = heapClassInst.heap32[r0 + numDefine49];
        r1 = r1 << numDefine2;
        r0 = (r0 + r1) | 0;
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0];
        commonVariable.rg0 = r0;
        
    }

    public static void zn23btDiscreteDynamicsWorld12removeActionEP17btActionInterface(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heap32[r0 + numDefine63];
        r3 = 0;
        repeat1:
        while (true) {
            if (r2 > r3) {
                r4 = heapClassInst.heap32[r0 + numDefine65];
                r5 = r3 << numDefine2;
                r4 = (r4 + r5) | 0;
                r4 = r4 >> numDefine2;
                r4 = heapClassInst.heap32[r4];
                if (r4 != r1) {
                    r3 = (r3 + 1) | 0;
                    continue repeat1;
                } else {
                    label = numDefine5;
                    break repeat1;
                }
            } else {
                label = numDefine4;
                break repeat1;
            }
        }
        if (label == numDefine4) {
            r3 = r2;
        }
        if (!(r2 <= r3)) {
            r1 = (r2 + -1) | 0;
            r2 = r3 << numDefine2;
            r3 = heapClassInst.heap32[r0 + numDefine65];
            r1 = r1 << numDefine2;
            r2 = (r3 + r2) | 0;
            r3 = (r3 + r1) | 0;
            r2 = r2 >> numDefine2;
            r3 = r3 >> numDefine2;
            r4 = heapClassInst.heap32[r2];
            r3 = heapClassInst.heap32[r3];
            heapClassInst.heap32[r2] = r3;
            r2 = heapClassInst.heap32[r0 + numDefine65];
            r1 = (r2 + r1) | 0;
            r1 = r1 >> numDefine2;
            heapClassInst.heap32[r1] = r4;
            r1 = heapClassInst.heap32[r0 + numDefine63];
            r1 = (r1 + -1) | 0;
            heapClassInst.heap32[r0 + numDefine63] = r1;
        }
        
    }

    public static void zzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoEN27InplaceSolverIslandCallbackD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztvzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = heapClassInst.heap32[r2 + numDefine21];
        if (!(r1 == 0)) {
            r3 = heapClassInst.heapU8[r0 + numDefine88];
            if (!(r3 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine21] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine88] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine21] = 0;
        heapClassInst.heap32[r2 + numDefine19] = 0;
        heapClassInst.heap32[r2 + numDefine20] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine16];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine68];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine16] = 0;
        }
        heapClassInst.heap8[r0 + numDefine68] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine16] = 0;
        heapClassInst.heap32[r2 + numDefine14] = 0;
        heapClassInst.heap32[r2 + numDefine15] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine11];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine48];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine11] = 0;
        }
        heapClassInst.heap8[r0 + numDefine48] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine11] = 0;
        heapClassInst.heap32[r2 + numDefine9] = 0;
        heapClassInst.heap32[r2 + numDefine10] = 0;
        
    }

    public static void zzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoEN27InplaceSolverIslandCallbackD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztvzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = heapClassInst.heap32[r2 + numDefine21];
        if (!(r1 == 0)) {
            r3 = heapClassInst.heapU8[r0 + numDefine88];
            if (!(r3 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine21] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine88] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine21] = 0;
        heapClassInst.heap32[r2 + numDefine19] = 0;
        heapClassInst.heap32[r2 + numDefine20] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine16];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine68];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine16] = 0;
        }
        heapClassInst.heap8[r0 + numDefine68] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine16] = 0;
        heapClassInst.heap32[r2 + numDefine14] = 0;
        heapClassInst.heap32[r2 + numDefine15] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine11];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine48];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine11] = 0;
        }
        heapClassInst.heap8[r0 + numDefine48] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine11] = 0;
        heapClassInst.heap32[r2 + numDefine9] = 0;
        heapClassInst.heap32[r2 + numDefine10] = 0;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn35btDiscrete(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int label = 0;
        i7 = sp + numDefineNeg48;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[fp + numDefine5];
        r3 = heapClassInst.heap32[fp + 1];
        r4 = heapClassInst.heap32[fp + numDefine2];
        r5 = heapClassInst.heap32[fp + numDefine3];
        r6 = heapClassInst.heap32[fp + numDefine4];
        r7 = heapClassInst.heap32[r1 + numDefine4];
        repeat1:
        do {
            if (r2 < 0) {
                r0 = 0;
                r0 = (r0 - r6) | 0;
                if (r7 == r0) {
                    break repeat1;
                } else {
                    r0 = heapClassInst.heap32[r1 + numDefine2];
                    r2 = r0 >> numDefine2;
                    r2 = heapClassInst.heap32[r2];
                    r2 = r2 >> numDefine2;
                    r2 = heapClassInst.heap32[r2 + numDefine3];
                    r8 = heapClassInst.heap32[r1 + numDefine7];
                    r9 = heapClassInst.heap32[r1 + numDefine6];
                    r10 = heapClassInst.heap32[r1 + numDefine5];
                    r11 = heapClassInst.heap32[r1 + 1];
                    r1 = heapClassInst.heap32[r1 + numDefine3];
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r3;
                    heapClassInst.heap32[g0 + numDefine2] = r4;
                    heapClassInst.heap32[g0 + numDefine3] = r5;
                    heapClassInst.heap32[g0 + numDefine4] = r6;
                    heapClassInst.heap32[g0 + numDefine5] = r1;
                    heapClassInst.heap32[g0 + numDefine6] = r7;
                    heapClassInst.heap32[g0 + numDefine7] = r11;
                    heapClassInst.heap32[g0 + numDefine8] = r10;
                    heapClassInst.heap32[g0 + numDefine9] = r9;
                    heapClassInst.heap32[g0 + numDefine10] = r8;
                    functionTable.get(r2 >> numDefine2).accept(i7);
                    
                }
            } else {
                r8 = 1;
                r9 = numDefine4;
                r10 = 0;
                repeat5:
                while (true) {
                    if (r7 > r10) {
                        r11 = heapClassInst.heap32[r1 + numDefine3];
                        r12 = r10 << numDefine2;
                        r12 = (r11 + r12) | 0;
                        r12 = r12 >> numDefine2;
                        r12 = heapClassInst.heap32[r12];
                        r12 = r12 >> numDefine2;
                        r13 = heapClassInst.heap32[r12 + numDefine5];
                        r13 = r13 >> numDefine2;
                        r13 = heapClassInst.heap32[r13 + numDefine52];
                        if (r13 < 0) {
                            r13 = heapClassInst.heap32[r12 + numDefine6];
                            r13 = r13 >> numDefine2;
                            r13 = heapClassInst.heap32[r13 + numDefine52];
                        }
                        r10 = (r10 + 1) | 0;
                        r9 = (r9 + numDefineNeg4) | 0;
                        r8 = (r8 + -1) | 0;
                        if (r13 == r2) {
                            label = numDefine9;
                            break repeat5;
                        } else {
                            label = numDefine7;
                        }
                    } else {
                        label = numDefine8;
                        break repeat5;
                    }
                }
                repeat11:
                do {
                    switch (label) {
                        case numDefine9:
                            r10 = r7 > r10 ? r7 : r10;
                            r7 = (r11 - r9) | 0;
                            r9 = (r10 + r8) | 0;
                            r8 = 0;
                            r10 = r7;
                            while (true) {
                                r11 = r10 >> numDefine2;
                                r11 = heapClassInst.heap32[r11];
                                r11 = r11 >> numDefine2;
                                r12 = heapClassInst.heap32[r11 + numDefine5];
                                r12 = r12 >> numDefine2;
                                r12 = heapClassInst.heap32[r12 + numDefine52];
                                if (r12 < 0) {
                                    r12 = heapClassInst.heap32[r11 + numDefine6];
                                    r12 = r12 >> numDefine2;
                                    r12 = heapClassInst.heap32[r12 + numDefine52];
                                }

                                r11 = r12 == r2 ? 1 : 0;
                                r11 = r11 & 1;
                                r9 = (r9 + -1) | 0;
                                r8 = (r11 + r8) | 0;
                                r10 = (r10 + numDefine4) | 0;
                                if (!(r9 != 0)) {
                                    break repeat11;
                                }
                            }
                        case numDefine8:
                            r7 = 0;
                            r8 = r7;
                            break;
                        default:
                            break;
                    }
                } while (false);
                r2 = heapClassInst.heap32[r1 + 1];
                r9 = r2 >> numDefine2;
                r9 = heapClassInst.heap32[r9 + numDefine17];
                if (r9 < numDefine2) {
                    r0 = 0;
                    r0 = (r0 - r6) | 0;
                    if (r8 == r0) {
                        break repeat1;
                    } else {
                        r0 = heapClassInst.heap32[r1 + numDefine2];
                        r9 = r0 >> numDefine2;
                        r9 = heapClassInst.heap32[r9];
                        r9 = r9 >> numDefine2;
                        r9 = heapClassInst.heap32[r9 + numDefine3];
                        r10 = heapClassInst.heap32[r1 + numDefine7];
                        r11 = heapClassInst.heap32[r1 + numDefine6];
                        r1 = heapClassInst.heap32[r1 + numDefine5];
                        heapClassInst.heap32[g0] = r0;
                        heapClassInst.heap32[g0 + 1] = r3;
                        heapClassInst.heap32[g0 + numDefine2] = r4;
                        heapClassInst.heap32[g0 + numDefine3] = r5;
                        heapClassInst.heap32[g0 + numDefine4] = r6;
                        heapClassInst.heap32[g0 + numDefine5] = r7;
                        heapClassInst.heap32[g0 + numDefine6] = r8;
                        heapClassInst.heap32[g0 + numDefine7] = r2;
                        heapClassInst.heap32[g0 + numDefine8] = r1;
                        heapClassInst.heap32[g0 + numDefine9] = r11;
                        heapClassInst.heap32[g0 + numDefine10] = r10;
                        functionTable.get(r9 >> numDefine2).accept(i7);
                        
                    }
                } else {
                    repeat24:
                    do {
                        if (r4 > 0) {
                            r2 = heapClassInst.heap32[r1 + numDefine9];
                            while (true) {
                                r9 = heapClassInst.heap32[r1 + numDefine10];
                                if (r9 == r2) {
                                    r10 = 1;
                                    r11 = r2 << 1;
                                    r11 = r2 == 0 ? r10 : r11;
                                    if (!(r9 >= r11)) {
                                        if (r11 != 0) {
                                            r9 = gNumAlignedAllocs;
                                            r9 = r9 >> numDefine2;
                                            r12 = heapClassInst.heap32[r9];
                                            r13 = r11 << numDefine2;
                                            r12 = (r12 + 1) | 0;
                                            r13 = r13 | numDefine3;
                                            heapClassInst.heap32[r9] = r12;
                                            r9 = (r13 + numDefine16) | 0;
                                            heapClassInst.heap32[g0] = r9;
                                            mallocNew(i7);
                                            r9 = commonVariable.rg0;
                                            if (r9 != 0) {
                                                r12 = 0;
                                                r13 = (r9 + numDefine4) | 0;
                                                r12 = (r12 - r13) | 0;
                                                r12 = r12 & numDefine15;
                                                r12 = (r9 + r12) | 0;
                                                r13 = (r12 + numDefine4) | 0;
                                                r12 = r12 >> numDefine2;
                                                heapClassInst.heap32[r12] = r9;
                                                r9 = r13;
                                            }
                                        } else {
                                            r9 = 0;
                                        }
                                        if (r2 < 1) {
                                            r13 = heapClassInst.heap32[r1 + numDefine11];
                                        } else {
                                            r12 = 0;
                                            repeat39:
                                            while (true) {
                                                r13 = heapClassInst.heap32[r1 + numDefine11];
                                                r14 = r12 << numDefine2;
                                                r15 = (r13 + r14) | 0;
                                                r15 = r15 >> numDefine2;
                                                r14 = (r9 + r14) | 0;
                                                r15 = heapClassInst.heap32[r15];
                                                r12 = (r12 + 1) | 0;
                                                r14 = r14 >> numDefine2;
                                                heapClassInst.heap32[r14] = r15;
                                                if (!(r2 != r12)) {
                                                    break repeat39;
                                                }
                                            }
                                        }
                                        if (r13 != 0) {
                                            r12 = heapClassInst.heapU8[r0 + numDefine48];
                                            if (r12 != 0) {
                                                r2 = gNumAlignedFree;
                                                r2 = r2 >> numDefine2;
                                                r12 = heapClassInst.heap32[r2];
                                                r12 = (r12 + 1) | 0;
                                                r13 = r13 >> numDefine2;
                                                heapClassInst.heap32[r2] = r12;
                                                r2 = heapClassInst.heap32[r13 + -1];
                                                heapClassInst.heap32[g0] = r2;
                                                free(i7);
                                                r2 = heapClassInst.heap32[r1 + numDefine9];
                                            }
                                            heapClassInst.heap32[r1 + numDefine11] = 0;
                                        }
                                        heapClassInst.heap8[r0 + numDefine48] = (byte) r10;
                                        heapClassInst.heap32[r1 + numDefine11] = r9;
                                        heapClassInst.heap32[r1 + numDefine10] = r11;
                                    }
                                }
                                r9 = r3 >> numDefine2;
                                r2 = r2 << numDefine2;
                                r10 = heapClassInst.heap32[r1 + numDefine11];
                                r2 = (r10 + r2) | 0;
                                r9 = heapClassInst.heap32[r9];
                                r2 = r2 >> numDefine2;
                                heapClassInst.heap32[r2] = r9;
                                r2 = heapClassInst.heap32[r1 + numDefine9];
                                r2 = (r2 + 1) | 0;
                                r4 = (r4 + -1) | 0;
                                r3 = (r3 + numDefine4) | 0;
                                heapClassInst.heap32[r1 + numDefine9] = r2;
                                if (!(r4 != 0)) {
                                    break repeat24;
                                }
                            }
                        }
                    } while (false);
                    repeat50:
                    do {
                        if (!(r6 < 1)) {
                            r2 = heapClassInst.heap32[r1 + numDefine14];
                            while (true) {
                                r3 = heapClassInst.heap32[r1 + numDefine15];
                                if (r3 == r2) {
                                    r4 = 1;
                                    r9 = r2 << 1;
                                    r9 = r2 == 0 ? r4 : r9;
                                    if (!(r3 >= r9)) {
                                        if (r9 != 0) {
                                            r3 = gNumAlignedAllocs;
                                            r3 = r3 >> numDefine2;
                                            r10 = heapClassInst.heap32[r3];
                                            r11 = r9 << numDefine2;
                                            r10 = (r10 + 1) | 0;
                                            r11 = r11 | numDefine3;
                                            heapClassInst.heap32[r3] = r10;
                                            r3 = (r11 + numDefine16) | 0;
                                            heapClassInst.heap32[g0] = r3;
                                            mallocNew(i7);
                                            r3 = commonVariable.rg0;
                                            if (r3 != 0) {
                                                r10 = 0;
                                                r11 = (r3 + numDefine4) | 0;
                                                r10 = (r10 - r11) | 0;
                                                r10 = r10 & numDefine15;
                                                r10 = (r3 + r10) | 0;
                                                r11 = (r10 + numDefine4) | 0;
                                                r10 = r10 >> numDefine2;
                                                heapClassInst.heap32[r10] = r3;
                                                r3 = r11;
                                            }
                                        } else {
                                            r3 = 0;
                                        }
                                        if (r2 < 1) {
                                            r11 = heapClassInst.heap32[r1 + numDefine16];
                                        } else {
                                            r10 = 0;
                                            repeat65:
                                            while (true) {
                                                r11 = heapClassInst.heap32[r1 + numDefine16];
                                                r12 = r10 << numDefine2;
                                                r13 = (r11 + r12) | 0;
                                                r13 = r13 >> numDefine2;
                                                r12 = (r3 + r12) | 0;
                                                r13 = heapClassInst.heap32[r13];
                                                r10 = (r10 + 1) | 0;
                                                r12 = r12 >> numDefine2;
                                                heapClassInst.heap32[r12] = r13;
                                                if (!(r2 != r10)) {
                                                    break repeat65;
                                                }
                                            }
                                        }
                                        if (r11 != 0) {
                                            r10 = heapClassInst.heapU8[r0 + numDefine68];
                                            if (r10 != 0) {
                                                r2 = gNumAlignedFree;
                                                r2 = r2 >> numDefine2;
                                                r10 = heapClassInst.heap32[r2];
                                                r10 = (r10 + 1) | 0;
                                                r11 = r11 >> numDefine2;
                                                heapClassInst.heap32[r2] = r10;
                                                r2 = heapClassInst.heap32[r11 + -1];
                                                heapClassInst.heap32[g0] = r2;
                                                free(i7);
                                                r2 = heapClassInst.heap32[r1 + numDefine14];
                                            }
                                            heapClassInst.heap32[r1 + numDefine16] = 0;
                                        }
                                        heapClassInst.heap8[r0 + numDefine68] = (byte) r4;
                                        heapClassInst.heap32[r1 + numDefine16] = r3;
                                        heapClassInst.heap32[r1 + numDefine15] = r9;
                                    }
                                }
                                r3 = r5 >> numDefine2;
                                r2 = r2 << numDefine2;
                                r4 = heapClassInst.heap32[r1 + numDefine16];
                                r2 = (r4 + r2) | 0;
                                r3 = heapClassInst.heap32[r3];
                                r2 = r2 >> numDefine2;
                                heapClassInst.heap32[r2] = r3;
                                r2 = heapClassInst.heap32[r1 + numDefine14];
                                r2 = (r2 + 1) | 0;
                                r6 = (r6 + -1) | 0;
                                r5 = (r5 + numDefine4) | 0;
                                heapClassInst.heap32[r1 + numDefine14] = r2;
                                if (!(r6 != 0)) {
                                    break repeat50;
                                }
                            }
                        }
                    } while (false);
                    repeat76:
                    do {
                        if (r8 > 0) {
                            r2 = heapClassInst.heap32[r1 + numDefine19];
                            while (true) {
                                r3 = heapClassInst.heap32[r1 + numDefine20];
                                if (r3 == r2) {
                                    r4 = 1;
                                    r5 = r2 << 1;
                                    r5 = r2 == 0 ? r4 : r5;
                                    if (!(r3 >= r5)) {
                                        if (r5 != 0) {
                                            r3 = gNumAlignedAllocs;
                                            r3 = r3 >> numDefine2;
                                            r6 = heapClassInst.heap32[r3];
                                            r9 = r5 << numDefine2;
                                            r6 = (r6 + 1) | 0;
                                            r9 = r9 | numDefine3;
                                            heapClassInst.heap32[r3] = r6;
                                            r3 = (r9 + numDefine16) | 0;
                                            heapClassInst.heap32[g0] = r3;
                                            mallocNew(i7);
                                            r3 = commonVariable.rg0;
                                            if (r3 != 0) {
                                                r6 = 0;
                                                r9 = (r3 + numDefine4) | 0;
                                                r6 = (r6 - r9) | 0;
                                                r6 = r6 & numDefine15;
                                                r6 = (r3 + r6) | 0;
                                                r9 = (r6 + numDefine4) | 0;
                                                r6 = r6 >> numDefine2;
                                                heapClassInst.heap32[r6] = r3;
                                                r3 = r9;
                                            }
                                        } else {
                                            r3 = 0;
                                        }
                                        if (r2 < 1) {
                                            r9 = heapClassInst.heap32[r1 + numDefine21];
                                        } else {
                                            r6 = 0;
                                            repeat91:
                                            while (true) {
                                                r9 = heapClassInst.heap32[r1 + numDefine21];
                                                r10 = r6 << numDefine2;
                                                r11 = (r9 + r10) | 0;
                                                r11 = r11 >> numDefine2;
                                                r10 = (r3 + r10) | 0;
                                                r11 = heapClassInst.heap32[r11];
                                                r6 = (r6 + 1) | 0;
                                                r10 = r10 >> numDefine2;
                                                heapClassInst.heap32[r10] = r11;
                                                if (!(r2 != r6)) {
                                                    break repeat91;
                                                }
                                            }
                                        }
                                        if (r9 != 0) {
                                            r6 = heapClassInst.heapU8[r0 + numDefine88];
                                            if (r6 != 0) {
                                                r2 = gNumAlignedFree;
                                                r2 = r2 >> numDefine2;
                                                r6 = heapClassInst.heap32[r2];
                                                r6 = (r6 + 1) | 0;
                                                r9 = r9 >> numDefine2;
                                                heapClassInst.heap32[r2] = r6;
                                                r2 = heapClassInst.heap32[r9 + -1];
                                                heapClassInst.heap32[g0] = r2;
                                                free(i7);
                                                r2 = heapClassInst.heap32[r1 + numDefine19];
                                            }
                                            heapClassInst.heap32[r1 + numDefine21] = 0;
                                        }
                                        heapClassInst.heap8[r0 + numDefine88] = (byte) r4;
                                        heapClassInst.heap32[r1 + numDefine21] = r3;
                                        heapClassInst.heap32[r1 + numDefine20] = r5;
                                    }
                                }
                                r3 = r7 >> numDefine2;
                                r2 = r2 << numDefine2;
                                r4 = heapClassInst.heap32[r1 + numDefine21];
                                r2 = (r4 + r2) | 0;
                                r3 = heapClassInst.heap32[r3];
                                r2 = r2 >> numDefine2;
                                heapClassInst.heap32[r2] = r3;
                                r2 = heapClassInst.heap32[r1 + numDefine19];
                                r2 = (r2 + 1) | 0;
                                r8 = (r8 + -1) | 0;
                                r7 = (r7 + numDefine4) | 0;
                                heapClassInst.heap32[r1 + numDefine19] = r2;
                                if (!(r8 != 0)) {
                                    break repeat76;
                                }
                            }
                        } else {
                            r2 = heapClassInst.heap32[r1 + numDefine19];
                        }
                    } while (false);
                    r3 = heapClassInst.heap32[r1 + 1];
                    r3 = r3 >> numDefine2;
                    r1 = heapClassInst.heap32[r1 + numDefine14];
                    r1 = (r1 + r2) | 0;
                    r2 = heapClassInst.heap32[r3 + numDefine17];
                    if (!(r1 <= r2)) {
                        heapClassInst.heap32[g0] = r0;
                        zzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoEN27InplaceSolverIslandCallback18processConstraintsEv(i7);
                    }
                }
            }
        } while (false);
        
    }

    static void zn20btAlignedObjectArrayIP17btTypedConstraintE17quickSortInternalI33btSortConstraintOnIslandPredicateEEvTIi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine2];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = (r0 + r1) | 0;
        r3 = r2 >>> numDefine31;
        r4 = heapClassInst.heap32[fp];
        r2 = (r2 + r3) | 0;
        r3 = r4 >> numDefine2;
        r2 = r2 & numDefine83646;
        r5 = heapClassInst.heap32[r3 + numDefine3];
        r2 = r2 << 1;
        r2 = (r5 + r2) | 0;
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2];
        r5 = r1;
        r6 = r0;
        repeat1:
        while (true) {
            r7 = r2 >> numDefine2;
            r8 = heapClassInst.heap32[r7 + numDefine5];
            r8 = r8 >> numDefine2;
            r9 = heapClassInst.heap32[r3 + numDefine3];
            r8 = heapClassInst.heap32[r8 + numDefine52];
            repeat3:
            while (true) {
                r10 = r5 << numDefine2;
                r10 = (r9 + r10) | 0;
                r10 = r10 >> numDefine2;
                r11 = heapClassInst.heap32[r10];
                if (r8 < 0) {
                    r12 = heapClassInst.heap32[r7 + numDefine6];
                    r12 = r12 >> numDefine2;
                    r12 = heapClassInst.heap32[r12 + numDefine52];
                } else {
                    r12 = r8;
                }
                r13 = r11 >> numDefine2;
                r14 = heapClassInst.heap32[r13 + numDefine5];
                r14 = r14 >> numDefine2;
                r14 = heapClassInst.heap32[r14 + numDefine52];
                if (r14 < 0) {
                    r14 = heapClassInst.heap32[r13 + numDefine6];
                    r14 = r14 >> numDefine2;
                    r14 = heapClassInst.heap32[r14 + numDefine52];
                }
                if (r14 < r12) {
                    r5 = (r5 + 1) | 0;
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
            repeat13:
            while (true) {
                r12 = r6 << numDefine2;
                r13 = (r9 + r12) | 0;
                r13 = r13 >> numDefine2;
                r13 = heapClassInst.heap32[r13];
                r14 = r13 >> numDefine2;
                r15 = heapClassInst.heap32[r14 + numDefine5];
                r15 = r15 >> numDefine2;
                r15 = heapClassInst.heap32[r15 + numDefine52];
                if (r15 < 0) {
                    r15 = heapClassInst.heap32[r14 + numDefine6];
                    r15 = r15 >> numDefine2;
                    r15 = heapClassInst.heap32[r15 + numDefine52];
                }
                if (r8 < 0) {
                    r14 = heapClassInst.heap32[r7 + numDefine6];
                    r14 = r14 >> numDefine2;
                    r14 = heapClassInst.heap32[r14 + numDefine52];
                } else {
                    r14 = r8;
                }
                if (r14 < r15) {
                    r6 = (r6 + -1) | 0;
                    continue repeat13;
                } else {
                    break repeat13;
                }
            }
            if (r5 <= r6) {
                heapClassInst.heap32[r10] = r13;
                r7 = heapClassInst.heap32[r3 + numDefine3];
                r7 = (r7 + r12) | 0;
                r5 = (r5 + 1) | 0;
                r6 = (r6 + -1) | 0;
                r7 = r7 >> numDefine2;
                heapClassInst.heap32[r7] = r11;
            }
            if (r5 <= r6) {
                continue repeat1;
            } else {
                break repeat1;
            }
        }
        if (!(r6 <= r1)) {
            heapClassInst.heap32[g0] = r4;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = r6;
            zn20btAlignedObjectArrayIP17btTypedConstraintE17quickSortInternalI33btSortConstraintOnIslandPredicateEEvTIi(i7);
        }
        if (!(r5 >= r0)) {
            heapClassInst.heap32[g0] = r4;
            heapClassInst.heap32[g0 + 1] = r5;
            heapClassInst.heap32[g0 + numDefine2] = r0;
            zn20btAlignedObjectArrayIP17btTypedConstraintE17quickSortInternalI33btSortConstraintOnIslandPredicateEEvTIi(i7);
        }
        return;
    }

    public static void zn23btDiscreteDynamicsWorld9serializeEP12btSerializer(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine8];
        r3 = heapClassInst.heap32[fp];
        heapClassInst.heap32[g0] = r0;
        r4 = r3 >> numDefine2;
        functionTable.get(r2 >> numDefine2).accept(i7);
        r2 = heapClassInst.heap32[r4 + numDefine2];
        if (!(r2 < 1)) {
            r2 = 0;
            repeat3:
            while (true) {
                r5 = heapClassInst.heap32[r4 + numDefine4];
                r6 = r2 << numDefine2;
                r5 = (r5 + r6) | 0;
                r5 = r5 >> numDefine2;
                r5 = heapClassInst.heap32[r5];
                r6 = heapClassInst.heapU8[r5 + numDefine232];
                r6 = r6 & numDefine2;
                if (!(r6 == 0)) {
                    r6 = r5 >> numDefine2;
                    r7 = heapClassInst.heap32[r6];
                    r7 = r7 >> numDefine2;
                    r7 = heapClassInst.heap32[r7 + numDefine4];
                    heapClassInst.heap32[g0] = r5;
                    functionTable.get(r7 >> numDefine2).accept(i7);
                    r8 = heapClassInst.heap32[r1];
                    r8 = r8 >> numDefine2;
                    r8 = heapClassInst.heap32[r8 + numDefine4];
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
                    heapClassInst.heap32[g0 + numDefine2] = 1;
                    functionTable.get(r8 >> numDefine2).accept(i7);
                    r7 = commonVariable.rg0;
                    r6 = heapClassInst.heap32[r6];
                    r6 = r6 >> numDefine2;
                    r8 = r7 >> numDefine2;
                    r6 = heapClassInst.heap32[r6 + numDefine5];
                    r8 = heapClassInst.heap32[r8 + numDefine2];
                    heapClassInst.heap32[g0] = r5;
                    heapClassInst.heap32[g0 + 1] = r8;
                    heapClassInst.heap32[g0 + numDefine2] = r0;
                    functionTable.get(r6 >> numDefine2).accept(i7);
                    r8 = heapClassInst.heap32[r1];
                    r8 = r8 >> numDefine2;
                    r8 = heapClassInst.heap32[r8 + numDefine5];
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r7;
                    heapClassInst.heap32[g0 + numDefine2] = commonVariable.rg0;
                    heapClassInst.heap32[g0 + numDefine3] = (int) numDefine45650;
                    heapClassInst.heap32[g0 + numDefine4] = r5;
                    functionTable.get(r8 >> numDefine2).accept(i7);
                }
                r2 = (r2 + 1) | 0;
                r5 = heapClassInst.heap32[r4 + numDefine2];
                if (r5 > r2) {
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
        }
        r2 = heapClassInst.heap32[r4 + numDefine47];
        repeat9:
        do {
            if (!(r2 < 1)) {
                r2 = 0;
                repeat11:
                while (true) {
                    r5 = r2 << numDefine2;
                    r6 = heapClassInst.heap32[r4 + numDefine49];
                    r5 = (r6 + r5) | 0;
                    r5 = r5 >> numDefine2;
                    r5 = heapClassInst.heap32[r5];
                    r6 = r5 >> numDefine2;
                    r7 = heapClassInst.heap32[r6];
                    r7 = r7 >> numDefine2;
                    r7 = heapClassInst.heap32[r7 + numDefine9];
                    heapClassInst.heap32[g0] = r5;
                    functionTable.get(r7 >> numDefine2).accept(i7);
                    r8 = heapClassInst.heap32[r1];
                    r8 = r8 >> numDefine2;
                    r8 = heapClassInst.heap32[r8 + numDefine4];
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
                    heapClassInst.heap32[g0 + numDefine2] = 1;
                    functionTable.get(r8 >> numDefine2).accept(i7);
                    r7 = commonVariable.rg0;
                    r6 = heapClassInst.heap32[r6];
                    r6 = r6 >> numDefine2;
                    r8 = r7 >> numDefine2;
                    r6 = heapClassInst.heap32[r6 + numDefine10];
                    r8 = heapClassInst.heap32[r8 + numDefine2];
                    heapClassInst.heap32[g0] = r5;
                    heapClassInst.heap32[g0 + 1] = r8;
                    heapClassInst.heap32[g0 + numDefine2] = r0;
                    functionTable.get(r6 >> numDefine2).accept(i7);
                    r8 = heapClassInst.heap32[r1];
                    r8 = r8 >> numDefine2;
                    r8 = heapClassInst.heap32[r8 + numDefine5];
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r7;
                    heapClassInst.heap32[g0 + numDefine2] = commonVariable.rg0;
                    heapClassInst.heap32[g0 + numDefine3] = (int) numDefine41027;
                    heapClassInst.heap32[g0 + numDefine4] = r5;
                    r2 = (r2 + 1) | 0;
                    functionTable.get(r8 >> numDefine2).accept(i7);
                    r5 = heapClassInst.heap32[r4 + numDefine47];
                    if (r5 > r2) {
                        continue repeat11;
                    } else {
                        break repeat9;
                    }
                }
            }
        } while (false);
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r0;
        zn16btCollisionWorld25serializeCollisionObjectsEP12btSerializer(i7);
        r1 = heapClassInst.heap32[r1];
        r1 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine9];
        heapClassInst.heap32[g0] = r0;
        functionTable.get(r1 >> numDefine2).accept(i7);
        
    }

    public static void zn23btDiscreteDynamicsWorld19setConstraintSolverEP18btConstraintSolver(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heapU8[r0 + numDefine245];
        if (!(r1 == 0)) {
            r1 = r0 >> numDefine2;
            r1 = heapClassInst.heap32[r1 + numDefine44];
            if (!(r1 == 0)) {
                r2 = gNumAlignedFree;
                r2 = r2 >> numDefine2;
                r3 = heapClassInst.heap32[r2];
                r3 = (r3 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r2] = r3;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
        }
        r1 = heapClassInst.heap32[fp + 1];
        r2 = 0;
        r3 = r0 >> numDefine2;
        heapClassInst.heap8[r0 + numDefine245] = (byte) r2;
        heapClassInst.heap32[r3 + numDefine44] = r1;
        
    }

    public static void zn23btDiscreteDynamicsWorld25predictUnconstraintMotionEf(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg40;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr87;
        r1 = heapClassInst.heap32[fp];
        heapClassInst.heap32[g0] = r0;
        r0 = r1 >> numDefine2;
        zn15CProfileManager13StartProfileEPKc(i7);
        r1 = heapClassInst.heap32[r0 + numDefine52];
        if (!(r1 < 1)) {
            f0 = heapClassInst.heapFloat[fp + 1];
            r1 = 0;
            repeat3:
            while (true) {
                r2 = heapClassInst.heap32[r0 + numDefine54];
                r3 = r1 << numDefine2;
                r2 = (r2 + r3) | 0;
                r2 = r2 >> numDefine2;
                r2 = heapClassInst.heap32[r2];
                r3 = heapClassInst.heapU8[r2 + numDefine204];
                r3 = r3 & numDefine3;
                if (!(r3 != 0)) {
                    heapClassInst.heap32[g0] = r2;
                    heapClassInst.heapFloat[g0 + 1] = f0;
                    zn11btRigidBody19integrateVelocitiesEf(i7);
                    heapClassInst.heap32[g0] = r2;
                    heapClassInst.heapFloat[g0 + 1] = f0;
                    zn11btRigidBody12applyDampingEf(i7);
                    r3 = r2 >> numDefine2;
                    f1 = heapClassInst.heapFloat[r3 + numDefine76];
                    f2 = heapClassInst.heapFloat[r3 + numDefine77];
                    f3 = heapClassInst.heapFloat[r3 + numDefine78];
                    r3 = (r2 + numDefine4) | 0;
                    r4 = (r2 + numDefine320) | 0;
                    r2 = (r2 + numDefine68) | 0;
                    heapClassInst.heap32[g0] = r3;
                    heapClassInst.heapFloat[g0 + 1] = f1;
                    heapClassInst.heapFloat[g0 + numDefine2] = f2;
                    heapClassInst.heapFloat[g0 + numDefine3] = f3;
                    heapClassInst.heap32[g0 + numDefine4] = r4;
                    heapClassInst.heapFloat[g0 + numDefine5] = f0;
                    heapClassInst.heap32[g0 + numDefine6] = r2;
                    zn15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5FRS0(i7);
                }
                r1 = (r1 + 1) | 0;
                r2 = heapClassInst.heap32[r0 + numDefine52];
                if (r2 > r1) {
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
        }
        r0 = zn15CProfileManager11CurrentNodeE;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        r2 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + numDefine4];
        r3 = (r3 + -1) | 0;
        heapClassInst.heap32[r2 + numDefine4] = r3;
        repeat9:
        do {
            if (!(r3 != 0)) {
                r3 = heapClassInst.heap32[r2 + 1];
                if (r3 != 0) {
                    r1 = sp + numDefineNeg8;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r3 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r1 = r1 >> numDefine2;
                    r4 = heapClassInst.heap32[fp + numDefineNeg2];
                    r5 = heapClassInst.heap32[r3];
                    r4 = (r4 - r5) | 0;
                    r1 = heapClassInst.heap32[r1 + 1];
                    r3 = heapClassInst.heap32[r3 + 1];
                    r1 = (r1 - r3) | 0;
                    r3 = (int) ((r4 * numDefineN6) | 0);
                    r1 = (r1 + r3) | 0;
                    r3 = heapClassInst.heap32[r2 + numDefine3];
                    r1 = (r1 - r3) | 0;
                    f0 = uint(r1);
                    f1 = numDefine1000;
                    f2 = heapClassInst.heapFloat[r2 + numDefine2];
                    f0 = f0 / f1;
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r2 + numDefine2] = f0;
                    r1 = heapClassInst.heap32[r2 + numDefine4];
                    if (r1 != 0) {
                        break repeat9;
                    } else {
                        r1 = heapClassInst.heap32[r0];
                    }
                }
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1 + numDefine5];
                heapClassInst.heap32[r0] = r1;
            }
        } while (false);
        
    }

    public static void zn23btDiscreteDynamicsWorld26calculateSimulationIslandsEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr188;
        r1 = heapClassInst.heap32[fp];
        heapClassInst.heap32[g0] = r0;
        zn15CProfileManager13StartProfileEPKc(i7);
        r0 = r1 >> numDefine2;
        r2 = heapClassInst.heap32[r0 + numDefine45];
        r3 = r2 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine2];
        r4 = heapClassInst.heap32[r0 + numDefine6];
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = r4;
        functionTable.get(r3 >> numDefine2).accept(i7);
        r2 = heapClassInst.heap32[r0 + numDefine47];
        if (!(r2 < 1)) {
            r3 = 0;
            repeat3:
            while (true) {
                r4 = heapClassInst.heap32[r0 + numDefine49];
                r5 = r3 << numDefine2;
                r4 = (r4 + r5) | 0;
                r4 = r4 >> numDefine2;
                r4 = heapClassInst.heap32[r4];
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4 + numDefine5];
                repeat5:
                do {
                    if (!(r5 == 0)) {
                        r6 = heapClassInst.heapU8[r5 + numDefine204];
                        r6 = r6 & numDefine3;
                        if (!(r6 != 0)) {
                            r4 = heapClassInst.heap32[r4 + numDefine6];
                            if (!(r4 == 0)) {
                                r6 = heapClassInst.heapU8[r4 + numDefine204];
                                r6 = r6 & numDefine3;
                                if (!(r6 != 0)) {
                                    r5 = r5 >> numDefine2;
                                    r6 = heapClassInst.heap32[r5 + numDefine54];
                                    if (r6 == numDefine2) {
                                        label = numDefine8;
                                    } else {
                                        if (r6 != numDefine5) {
                                            label = numDefine10;
                                        } else {
                                            label = numDefine8;
                                        }
                                    }
                                    if (label == numDefine8) {
                                        r6 = r4 >> numDefine2;
                                        r6 = heapClassInst.heap32[r6 + numDefine54];
                                        if (r6 == numDefine2) {
                                            break repeat5;
                                        } else {
                                            if (r6 == numDefine5) {
                                                break repeat5;
                                            }
                                        }
                                    }
                                    r6 = heapClassInst.heap32[r0 + numDefine45];
                                    r5 = heapClassInst.heap32[r5 + numDefine52];
                                    r6 = r6 >> numDefine2;
                                    r7 = heapClassInst.heap32[r6 + numDefine4];
                                    r8 = r5 << numDefine3;
                                    r8 = (r7 + r8) | 0;
                                    r8 = r8 >> numDefine2;
                                    r4 = r4 >> numDefine2;
                                    r8 = heapClassInst.heap32[r8];
                                    r4 = heapClassInst.heap32[r4 + numDefine52];
                                    if (!(r8 == r5)) {
                                        repeat17:
                                        while (true) {
                                            r8 = r8 << numDefine3;
                                            r5 = r5 << numDefine3;
                                            r8 = (r7 + r8) | 0;
                                            r5 = (r7 + r5) | 0;
                                            r7 = r8 >> numDefine2;
                                            r5 = r5 >> numDefine2;
                                            r8 = heapClassInst.heap32[r7];
                                            heapClassInst.heap32[r5] = r8;
                                            r5 = heapClassInst.heap32[r7];
                                            r7 = heapClassInst.heap32[r6 + numDefine4];
                                            r8 = r5 << numDefine3;
                                            r8 = (r7 + r8) | 0;
                                            r8 = r8 >> numDefine2;
                                            r8 = heapClassInst.heap32[r8];
                                            if (!(r8 != r5)) {
                                                break repeat17;
                                            }
                                        }
                                    }
                                    r8 = r4 << numDefine3;
                                    r8 = (r7 + r8) | 0;
                                    r8 = r8 >> numDefine2;
                                    r8 = heapClassInst.heap32[r8];
                                    repeat20:
                                    do {
                                        if (!(r8 == r4)) {
                                            while (true) {
                                                r8 = r8 << numDefine3;
                                                r4 = r4 << numDefine3;
                                                r8 = (r7 + r8) | 0;
                                                r4 = (r7 + r4) | 0;
                                                r7 = r8 >> numDefine2;
                                                r4 = r4 >> numDefine2;
                                                r8 = heapClassInst.heap32[r7];
                                                heapClassInst.heap32[r4] = r8;
                                                r4 = heapClassInst.heap32[r7];
                                                r7 = heapClassInst.heap32[r6 + numDefine4];
                                                r8 = r4 << numDefine3;
                                                r8 = (r7 + r8) | 0;
                                                r8 = r8 >> numDefine2;
                                                r8 = heapClassInst.heap32[r8];
                                                if (!(r8 != r4)) {
                                                    break repeat20;
                                                }
                                            }
                                        }
                                    } while (false);
                                    if (!(r5 == r4)) {
                                        r5 = r5 << numDefine3;
                                        r7 = (r7 + r5) | 0;
                                        r7 = r7 >> numDefine2;
                                        heapClassInst.heap32[r7] = r4;
                                        r6 = heapClassInst.heap32[r6 + numDefine4];
                                        r4 = r4 << numDefine3;
                                        r4 = (r6 + r4) | 0;
                                        r5 = (r6 + r5) | 0;
                                        r4 = r4 >> numDefine2;
                                        r5 = r5 >> numDefine2;
                                        r6 = heapClassInst.heap32[r4 + 1];
                                        r5 = heapClassInst.heap32[r5 + 1];
                                        r5 = (r5 + r6) | 0;
                                        heapClassInst.heap32[r4 + 1] = r5;
                                    }
                                }
                            }
                        }
                    }
                } while (false);
                r3 = (r3 + 1) | 0;
                if (r2 != r3) {
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
        }
        r0 = heapClassInst.heap32[r0 + numDefine45];
        r2 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r2];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine3];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        r0 = zn15CProfileManager11CurrentNodeE;
        functionTable.get(r2 >> numDefine2).accept(i7);
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        r2 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + numDefine4];
        r3 = (r3 + -1) | 0;
        heapClassInst.heap32[r2 + numDefine4] = r3;
        repeat27:
        do {
            if (!(r3 != 0)) {
                r3 = heapClassInst.heap32[r2 + 1];
                if (r3 != 0) {
                    r1 = sp + numDefineNeg8;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r3 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r1 = r1 >> numDefine2;
                    r4 = heapClassInst.heap32[fp + numDefineNeg2];
                    r5 = heapClassInst.heap32[r3];
                    r4 = (r4 - r5) | 0;
                    r1 = heapClassInst.heap32[r1 + 1];
                    r3 = heapClassInst.heap32[r3 + 1];
                    r1 = (r1 - r3) | 0;
                    r3 = (int) ((r4 * numDefineN6) | 0);
                    r1 = (r1 + r3) | 0;
                    r3 = heapClassInst.heap32[r2 + numDefine3];
                    r1 = (r1 - r3) | 0;
                    f0 = uint(r1);
                    f1 = numDefine1000;
                    f2 = heapClassInst.heapFloat[r2 + numDefine2];
                    f0 = f0 / f1;
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r2 + numDefine2] = f0;
                    r1 = heapClassInst.heap32[r2 + numDefine4];
                    if (r1 != 0) {
                        break repeat27;
                    } else {
                        r1 = heapClassInst.heap32[r0];
                    }
                }
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1 + numDefine5];
                heapClassInst.heap32[r0] = r1;
            }
        } while (false);
        
    }

    static void zzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoEN27InplaceSolverIslandCallback18processConstraintsEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int label = 0;
        i7 = sp + numDefineNeg48;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine14];
        r3 = heapClassInst.heap32[r1 + numDefine19];
        r4 = (r3 + r2) | 0;
        if (!(r4 < 1)) {
            r4 = heapClassInst.heap32[r1 + numDefine2];
            r5 = r4 >> numDefine2;
            r5 = heapClassInst.heap32[r5];
            r5 = r5 >> numDefine2;
            r5 = heapClassInst.heap32[r5 + numDefine3];
            r6 = heapClassInst.heap32[r1 + numDefine7];
            r7 = heapClassInst.heap32[r1 + numDefine6];
            r8 = heapClassInst.heap32[r1 + numDefine5];
            r9 = heapClassInst.heap32[r1 + 1];
            r10 = heapClassInst.heap32[r1 + numDefine21];
            r11 = heapClassInst.heap32[r1 + numDefine16];
            r12 = heapClassInst.heap32[r1 + numDefine9];
            r13 = heapClassInst.heap32[r1 + numDefine11];
            heapClassInst.heap32[g0] = r4;
            heapClassInst.heap32[g0 + 1] = r13;
            heapClassInst.heap32[g0 + numDefine2] = r12;
            heapClassInst.heap32[g0 + numDefine3] = r11;
            heapClassInst.heap32[g0 + numDefine4] = r2;
            heapClassInst.heap32[g0 + numDefine5] = r10;
            heapClassInst.heap32[g0 + numDefine6] = r3;
            heapClassInst.heap32[g0 + numDefine7] = r9;
            heapClassInst.heap32[g0 + numDefine8] = r8;
            heapClassInst.heap32[g0 + numDefine9] = r7;
            heapClassInst.heap32[g0 + numDefine10] = r6;
            functionTable.get(r5 >> numDefine2).accept(i7);
        }
        r2 = heapClassInst.heap32[r1 + numDefine9];
        if (!(r2 > -1)) {
            r3 = heapClassInst.heap32[r1 + numDefine10];
            if (!(r3 > -1)) {
                r3 = heapClassInst.heap32[r1 + numDefine11];
                if (!(r3 == 0)) {
                    r4 = heapClassInst.heapU8[r0 + numDefine48];
                    if (!(r4 == 0)) {
                        r4 = gNumAlignedFree;
                        r4 = r4 >> numDefine2;
                        r5 = heapClassInst.heap32[r4];
                        r5 = (r5 + 1) | 0;
                        r3 = r3 >> numDefine2;
                        heapClassInst.heap32[r4] = r5;
                        r3 = heapClassInst.heap32[r3 + -1];
                        heapClassInst.heap32[g0] = r3;
                        free(i7);
                    }
                    heapClassInst.heap32[r1 + numDefine11] = 0;
                }
                r3 = 1;
                heapClassInst.heap8[r0 + numDefine48] = (byte) r3;
                heapClassInst.heap32[r1 + numDefine11] = 0;
                heapClassInst.heap32[r1 + numDefine10] = 0;
            }
            repeat14:
            while (true) {
                r3 = r2 << numDefine2;
                r4 = heapClassInst.heap32[r1 + numDefine11];
                r3 = (r4 + r3) | 0;
                r2 = (r2 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r3] = 0;
                if (r2 != 0) {
                    continue repeat14;
                } else {
                    break repeat14;
                }
            }
        }
        heapClassInst.heap32[r1 + numDefine9] = 0;
        r2 = heapClassInst.heap32[r1 + numDefine14];
        repeat17:
        do {
            if (!(r2 > -1)) {
                r3 = heapClassInst.heap32[r1 + numDefine15];
                if (!(r3 > -1)) {
                    r3 = heapClassInst.heap32[r1 + numDefine16];
                    if (!(r3 == 0)) {
                        r4 = heapClassInst.heapU8[r0 + numDefine68];
                        if (!(r4 == 0)) {
                            r4 = gNumAlignedFree;
                            r4 = r4 >> numDefine2;
                            r5 = heapClassInst.heap32[r4];
                            r5 = (r5 + 1) | 0;
                            r3 = r3 >> numDefine2;
                            heapClassInst.heap32[r4] = r5;
                            r3 = heapClassInst.heap32[r3 + -1];
                            heapClassInst.heap32[g0] = r3;
                            free(i7);
                        }
                        heapClassInst.heap32[r1 + numDefine16] = 0;
                    }
                    r3 = 1;
                    heapClassInst.heap8[r0 + numDefine68] = (byte) r3;
                    heapClassInst.heap32[r1 + numDefine16] = 0;
                    heapClassInst.heap32[r1 + numDefine15] = 0;
                }
                repeat27:
                while (true) {
                    r3 = r2 << numDefine2;
                    r4 = heapClassInst.heap32[r1 + numDefine16];
                    r3 = (r4 + r3) | 0;
                    r2 = (r2 + 1) | 0;
                    r3 = r3 >> numDefine2;
                    heapClassInst.heap32[r3] = 0;
                    if (r2 != 0) {
                        continue repeat27;
                    } else {
                        break repeat17;
                    }
                }
            }
        } while (false);
        heapClassInst.heap32[r1 + numDefine14] = 0;
        r2 = heapClassInst.heap32[r1 + numDefine19];
        repeat30:
        do {
            if (!(r2 > -1)) {
                r3 = heapClassInst.heap32[r1 + numDefine20];
                if (!(r3 > -1)) {
                    r3 = heapClassInst.heap32[r1 + numDefine21];
                    if (!(r3 == 0)) {
                        r4 = heapClassInst.heapU8[r0 + numDefine88];
                        if (!(r4 == 0)) {
                            r4 = gNumAlignedFree;
                            r4 = r4 >> numDefine2;
                            r5 = heapClassInst.heap32[r4];
                            r5 = (r5 + 1) | 0;
                            r3 = r3 >> numDefine2;
                            heapClassInst.heap32[r4] = r5;
                            r3 = heapClassInst.heap32[r3 + -1];
                            heapClassInst.heap32[g0] = r3;
                            free(i7);
                        }
                        heapClassInst.heap32[r1 + numDefine21] = 0;
                    }
                    r3 = 1;
                    heapClassInst.heap8[r0 + numDefine88] = (byte) r3;
                    heapClassInst.heap32[r1 + numDefine21] = 0;
                    heapClassInst.heap32[r1 + numDefine20] = 0;
                }
                repeat40:
                while (true) {
                    r0 = r2 << numDefine2;
                    r3 = heapClassInst.heap32[r1 + numDefine21];
                    r0 = (r3 + r0) | 0;
                    r2 = (r2 + 1) | 0;
                    r0 = r0 >> numDefine2;
                    heapClassInst.heap32[r0] = 0;
                    if (r2 != 0) {
                        continue repeat40;
                    } else {
                        break repeat30;
                    }
                }
            }
        } while (false);
        heapClassInst.heap32[r1 + numDefine19] = 0;
        return;
    }

    public static void zn23btDiscreteDynamicsWorld9addActionEP17btActionInterface(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine64];
        r3 = heapClassInst.heap32[r1 + numDefine63];
        r4 = heapClassInst.heap32[fp + 1];
        if (r2 == r3) {
            r5 = 1;
            r6 = r3 << 1;
            r6 = r3 == 0 ? r5 : r6;
            if (!(r2 >= r6)) {
                if (r6 != 0) {
                    r2 = gNumAlignedAllocs;
                    r2 = r2 >> numDefine2;
                    r7 = heapClassInst.heap32[r2];
                    r8 = r6 << numDefine2;
                    r7 = (r7 + 1) | 0;
                    r8 = r8 | numDefine3;
                    heapClassInst.heap32[r2] = r7;
                    r2 = (r8 + numDefine16) | 0;
                    heapClassInst.heap32[g0] = r2;
                    mallocNew(i7);
                    r2 = commonVariable.rg0;
                    if (r2 != 0) {
                        r7 = 0;
                        r8 = (r2 + numDefine4) | 0;
                        r7 = (r7 - r8) | 0;
                        r7 = r7 & numDefine15;
                        r7 = (r2 + r7) | 0;
                        r8 = (r7 + numDefine4) | 0;
                        r7 = r7 >> numDefine2;
                        heapClassInst.heap32[r7] = r2;
                        r2 = r8;
                    }
                } else {
                    r2 = 0;
                }
                r7 = (r0 + numDefine260) | 0;
                if (r3 < 1) {
                    r8 = r7 >> numDefine2;
                    r9 = heapClassInst.heap32[r8];
                } else {
                    r8 = 0;
                    repeat12:
                    while (true) {
                        r9 = r7 >> numDefine2;
                        r9 = heapClassInst.heap32[r9];
                        r10 = r8 << numDefine2;
                        r11 = (r9 + r10) | 0;
                        r11 = r11 >> numDefine2;
                        r10 = (r2 + r10) | 0;
                        r11 = heapClassInst.heap32[r11];
                        r8 = (r8 + 1) | 0;
                        r10 = r10 >> numDefine2;
                        heapClassInst.heap32[r10] = r11;
                        if (!(r3 != r8)) {
                            break repeat12;
                        }
                    }
                    r7 = (r0 + numDefine260) | 0;
                }
                if (r9 != 0) {
                    r8 = heapClassInst.heapU8[r0 + numDefine264];
                    if (r8 != 0) {
                        r3 = gNumAlignedFree;
                        r3 = r3 >> numDefine2;
                        r8 = heapClassInst.heap32[r3];
                        r8 = (r8 + 1) | 0;
                        r9 = r9 >> numDefine2;
                        heapClassInst.heap32[r3] = r8;
                        r3 = heapClassInst.heap32[r9 + -1];
                        heapClassInst.heap32[g0] = r3;
                        free(i7);
                        r3 = heapClassInst.heap32[r1 + numDefine63];
                    }
                    r8 = r7 >> numDefine2;
                    heapClassInst.heap32[r8] = 0;
                }
                r7 = r7 >> numDefine2;
                heapClassInst.heap8[r0 + numDefine264] = (byte) r5;
                heapClassInst.heap32[r7] = r2;
                heapClassInst.heap32[r1 + numDefine64] = r6;
            }
        }
        r0 = r3 << numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine65];
        r0 = (r2 + r0) | 0;
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r0] = r4;
        r0 = heapClassInst.heap32[r1 + numDefine63];
        r0 = (r0 + 1) | 0;
        heapClassInst.heap32[r1 + numDefine63] = r0;
        
    }

    public static void zn23btDiscreteDynamicsWorld19integrateTransformsEf(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg264;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr794;
        r1 = heapClassInst.heap32[fp];
        heapClassInst.heap32[g0] = r0;
        r0 = r1 >> numDefine2;
        zn15CProfileManager13StartProfileEPKc(i7);
        r2 = heapClassInst.heap32[r0 + numDefine52];
        if (!(r2 < 1)) {
            f0 = heapClassInst.heapFloat[fp + 1];
            r2 = 0;
            r15 = -1;
            repeat3:
            while (true) {
                r3 = heapClassInst.heap32[r0 + numDefine54];
                r4 = r2 << numDefine2;
                r3 = (r3 + r4) | 0;
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3];
                r4 = r3 >> numDefine2;
                heapClassInst.heap32[r4 + numDefine60] = (int) numDefine53216;
                r5 = heapClassInst.heap32[r4 + numDefine54];
                if (!(r5 == numDefine2)) {
                    if (!(r5 == numDefine5)) {
                        r5 = heapClassInst.heapU8[r3 + numDefine204];
                        r5 = r5 & numDefine3;
                        if (!(r5 != 0)) {
                            f1 = heapClassInst.heapFloat[r4 + numDefine76];
                            f2 = heapClassInst.heapFloat[r4 + numDefine77];
                            f3 = heapClassInst.heapFloat[r4 + numDefine78];
                            r5 = (r3 + numDefine320) | 0;
                            r6 = (r3 + numDefine4) | 0;
                            r7 = sp + numDefineNeg80;
                            heapClassInst.heap32[g0] = r6;
                            heapClassInst.heapFloat[g0 + 1] = f1;
                            heapClassInst.heapFloat[g0 + numDefine2] = f2;
                            heapClassInst.heapFloat[g0 + numDefine3] = f3;
                            heapClassInst.heap32[g0 + numDefine4] = r5;
                            heapClassInst.heapFloat[g0 + numDefine5] = f0;
                            heapClassInst.heap32[g0 + numDefine6] = r7;
                            zn15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5FRS0(i7);
                            f1 = heapClassInst.heapFloat[r4 + numDefine62];
                            f1 = f1 * f1;
                            f2 = 0;
                            repeat9:
                            do {
                                if (!(f1 == f2)) {
                                    r8 = r7 >> numDefine2;
                                    f2 = heapClassInst.heapFloat[r8 + numDefine14];
                                    f3 = heapClassInst.heapFloat[r4 + numDefine15];
                                    f4 = heapClassInst.heapFloat[r8 + numDefine13];
                                    f5 = heapClassInst.heapFloat[r4 + numDefine14];
                                    f6 = heapClassInst.heapFloat[r8 + numDefine12];
                                    f7 = heapClassInst.heapFloat[r4 + numDefine13];
                                    f2 = f2 - f3;
                                    f3 = f4 - f5;
                                    f4 = f6 - f7;
                                    f4 = f4 * f4;
                                    f3 = f3 * f3;
                                    f3 = f4 + f3;
                                    f2 = f2 * f2;
                                    f2 = f3 + f2;
                                    if (!(f1 >= f2)) {
                                        r9 = twoEStr895;
                                        heapClassInst.heap32[g0] = r9;
                                        zn15CProfileManager13StartProfileEPKc(i7);
                                        r9 = heapClassInst.heap32[r4 + numDefine48];
                                        r9 = r9 >> numDefine2;
                                        r9 = heapClassInst.heap32[r9 + 1];
                                        if (!(r9 > numDefine19)) {
                                            r9 = gNumClampedCcdMotions;
                                            r9 = r9 >> numDefine2;
                                            r10 = heapClassInst.heap32[r9];
                                            r10 = (r10 + 1) | 0;
                                            heapClassInst.heap32[r9] = r10;
                                            r9 = heapClassInst.heap32[r0 + numDefine20];
                                            r10 = r9 >> numDefine2;
                                            r10 = heapClassInst.heap32[r10];
                                            r10 = r10 >> numDefine2;
                                            r10 = heapClassInst.heap32[r10 + numDefine9];
                                            r11 = heapClassInst.heap32[r0 + numDefine6];
                                            r12 = sp + numDefineNeg176;
                                            heapClassInst.heap32[g0] = r9;
                                            r9 = r12 >> numDefine2;
                                            functionTable.get(r10 >> numDefine2).accept(i7);
                                            r13 = 1;
                                            heapClassInst.heap32[r9 + 1] = numDefine53216;
                                            r14 = ztvn16btCollisionWorld27ClosestConvexResultCallbackE;
                                            heapClassInst.heap16[(sp + numDefineNeg168) >> 1] = (short) r13;
                                            r13 = (r14 + numDefine8) | 0;
                                            heapClassInst.heap16[(sp + numDefineNeg166) >> 1] = (short) r15;
                                            heapClassInst.heap32[fp + numDefineNeg44] = r13;
                                            heapClassInst.heap32[r9 + numDefine3] = heapClassInst.heap32[r4 + numDefine13];
                                            heapClassInst.heap32[r9 + numDefine4] = heapClassInst.heap32[r4 + numDefine14];
                                            heapClassInst.heap32[r9 + numDefine5] = heapClassInst.heap32[r4 + numDefine15];
                                            heapClassInst.heap32[r9 + numDefine6] = heapClassInst.heap32[r4 + numDefine16];
                                            heapClassInst.heap32[r9 + numDefine7] = heapClassInst.heap32[r8 + numDefine12];
                                            heapClassInst.heap32[r9 + numDefine8] = heapClassInst.heap32[r8 + numDefine13];
                                            heapClassInst.heap32[r9 + numDefine9] = heapClassInst.heap32[r8 + numDefine14];
                                            r14 = ztv34btClosestNotMeConvexResultCallback;
                                            heapClassInst.heap32[r9 + numDefine10] = heapClassInst.heap32[r8 + numDefine15];
                                            r8 = (r14 + numDefine8) | 0;
                                            heapClassInst.heap32[r9 + numDefine19] = 0;
                                            heapClassInst.heap32[fp + numDefineNeg44] = r8;
                                            heapClassInst.heap32[r9 + numDefine20] = r3;
                                            heapClassInst.heap32[r9 + numDefine21] = 0;
                                            heapClassInst.heap32[r9 + numDefine22] = commonVariable.rg0;
                                            r8 = sp + numDefineNeg232;
                                            heapClassInst.heap32[r9 + numDefine23] = r11;
                                            r10 = r8 >> numDefine2;
                                            f1 = heapClassInst.heapFloat[r4 + numDefine61];
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            heapClassInst.heap32[r10 + numDefine3] = (int) numDefine53216;
                                            heapClassInst.heap32[r10 + numDefine4] = (int) numDefine53216;
                                            r11 = ztv13btSphereShape;
                                            heapClassInst.heap32[r10 + numDefine5] = (int) numDefine53216;
                                            r11 = (r11 + numDefine8) | 0;
                                            heapClassInst.heap32[r10 + numDefine6] = 0;
                                            heapClassInst.heap32[fp + numDefineNeg58] = r11;
                                            heapClassInst.heap32[r10 + 1] = numDefine8;
                                            heapClassInst.heapFloat[r10 + numDefine7] = f1;
                                            heapClassInst.heapFloat[r10 + numDefine11] = f1;
                                            r10 = heapClassInst.heap32[r4 + numDefine47];
                                            r10 = heapClassInst.heapU16[(r10 + numDefine4) >> 1];
                                            heapClassInst.heap16[(sp + numDefineNeg168) >> 1] = (short) r10;
                                            r10 = heapClassInst.heap32[r4 + numDefine47];
                                            r10 = heapClassInst.heapU16[(r10 + numDefine6) >> 1];
                                            heapClassInst.heap16[(sp + numDefineNeg166) >> 1] = (short) r10;
                                            heapClassInst.heap32[g0] = r1;
                                            heapClassInst.heap32[g0 + 1] = r8;
                                            heapClassInst.heap32[g0 + numDefine2] = r6;
                                            heapClassInst.heap32[g0 + numDefine3] = r7;
                                            heapClassInst.heap32[g0 + numDefine4] = r12;
                                            heapClassInst.heap32[g0 + numDefine5] = 0;
                                            znk16btCollisionWorld15convexSweepTestEPK13btConvexShapeRK11btTransformS5RNS20ConvexResultCallbackEf(i7);
                                            f1 = heapClassInst.heapFloat[r9 + 1];
                                            f2 = 1;
                                            if (!(f1 >= f2)) {
                                                heapClassInst.heapFloat[r4 + numDefine60] = f1;
                                                f2 = heapClassInst.heapFloat[r4 + numDefine76];
                                                f3 = heapClassInst.heapFloat[r4 + numDefine77];
                                                f4 = heapClassInst.heapFloat[r4 + numDefine78];
                                                f1 = f1 * f0;
                                                heapClassInst.heap32[g0] = r6;
                                                heapClassInst.heapFloat[g0 + 1] = f2;
                                                heapClassInst.heapFloat[g0 + numDefine2] = f3;
                                                heapClassInst.heapFloat[g0 + numDefine3] = f4;
                                                heapClassInst.heap32[g0 + numDefine4] = r5;
                                                heapClassInst.heapFloat[g0 + numDefine5] = f1;
                                                heapClassInst.heap32[g0 + numDefine6] = r7;
                                                zn15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5FRS0(i7);
                                                heapClassInst.heap32[r4 + numDefine60] = 0;
                                            }
                                            r4 = ztv13btConvexShape;
                                            r4 = (r4 + numDefine8) | 0;
                                            heapClassInst.heap32[fp + numDefineNeg58] = r4;
                                            heapClassInst.heap32[fp + numDefineNeg44] = r13;
                                        }
                                        r4 = zn15CProfileManager11CurrentNodeE;
                                        r4 = r4 >> numDefine2;
                                        r5 = heapClassInst.heap32[r4];
                                        r6 = r5 >> numDefine2;
                                        r8 = heapClassInst.heap32[r6 + numDefine4];
                                        r8 = (r8 + -1) | 0;
                                        heapClassInst.heap32[r6 + numDefine4] = r8;
                                        if (!(r8 != 0)) {
                                            r8 = heapClassInst.heap32[r6 + 1];
                                            if (r8 != 0) {
                                                r5 = sp + numDefineNeg8;
                                                heapClassInst.heap32[g0] = r5;
                                                heapClassInst.heap32[g0 + 1] = 0;
                                                r8 = zl13gProfileClock2E0;
                                                getTimeOfDay(i7);
                                                r8 = r8 >> numDefine2;
                                                r8 = heapClassInst.heap32[r8];
                                                r8 = r8 >> numDefine2;
                                                r5 = r5 >> numDefine2;
                                                r9 = heapClassInst.heap32[fp + numDefineNeg2];
                                                r10 = heapClassInst.heap32[r8];
                                                r9 = (r9 - r10) | 0;
                                                r5 = heapClassInst.heap32[r5 + 1];
                                                r8 = heapClassInst.heap32[r8 + 1];
                                                r5 = (r5 - r8) | 0;
                                                r8 = (int) ((r9 * numDefineN6) | 0);
                                                r5 = (r5 + r8) | 0;
                                                r8 = heapClassInst.heap32[r6 + numDefine3];
                                                r5 = (r5 - r8) | 0;
                                                f1 = uint(r5);
                                                f2 = numDefine1000;
                                                f3 = heapClassInst.heapFloat[r6 + numDefine2];
                                                f1 = f1 / f2;
                                                f1 = f3 + f1;
                                                heapClassInst.heapFloat[r6 + numDefine2] = f1;
                                                r5 = heapClassInst.heap32[r6 + numDefine4];
                                                if (r5 != 0) {
                                                    break repeat9;
                                                } else {
                                                    r5 = heapClassInst.heap32[r4];
                                                }
                                            }
                                            r5 = r5 >> numDefine2;
                                            r5 = heapClassInst.heap32[r5 + numDefine5];
                                            heapClassInst.heap32[r4] = r5;
                                        }
                                    }
                                }
                            } while (false);
                            heapClassInst.heap32[g0] = r3;
                            heapClassInst.heap32[g0 + 1] = r7;
                            zn11btRigidBody18proceedToTransformERK11btTransform(i7);
                        }
                    }
                }
                r2 = (r2 + 1) | 0;
                r3 = heapClassInst.heap32[r0 + numDefine52];
                if (r3 > r2) {
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
        }
        r0 = zn15CProfileManager11CurrentNodeE;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        r2 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + numDefine4];
        r3 = (r3 + -1) | 0;
        heapClassInst.heap32[r2 + numDefine4] = r3;
        repeat26:
        do {
            if (!(r3 != 0)) {
                r3 = heapClassInst.heap32[r2 + 1];
                if (r3 != 0) {
                    r1 = sp + numDefineNeg16;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r3 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r1 = r1 >> numDefine2;
                    r4 = heapClassInst.heap32[fp + numDefineNeg4];
                    r5 = heapClassInst.heap32[r3];
                    r4 = (r4 - r5) | 0;
                    r1 = heapClassInst.heap32[r1 + 1];
                    r3 = heapClassInst.heap32[r3 + 1];
                    r1 = (r1 - r3) | 0;
                    r3 = (int) ((r4 * numDefineN6) | 0);
                    r1 = (r1 + r3) | 0;
                    r3 = heapClassInst.heap32[r2 + numDefine3];
                    r1 = (r1 - r3) | 0;
                    f0 = uint(r1);
                    f1 = numDefine1000;
                    f2 = heapClassInst.heapFloat[r2 + numDefine2];
                    f0 = f0 / f1;
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r2 + numDefine2] = f0;
                    r1 = heapClassInst.heap32[r2 + numDefine4];
                    if (r1 != 0) {
                        break repeat26;
                    } else {
                        r1 = heapClassInst.heap32[r0];
                    }
                }
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1 + numDefine5];
                heapClassInst.heap32[r0] = r1;
            }
        } while (false);
        
    }

    public static void zn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfo(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        int r19 = 0;
        int r20 = 0;
        int r21 = 0;
        int r22 = 0;
        int r23 = 0;
        int r24 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg168;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr996;
        heapClassInst.heap32[g0] = r0;
        r0 = sp + numDefineNeg48;
        zn15CProfileManager13StartProfileEPKc(i7);
        r1 = 1;
        r2 = r0 >> numDefine2;
        heapClassInst.heap8[sp + numDefineNeg32] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine3] = 0;
        r3 = heapClassInst.heap32[fp];
        heapClassInst.heap32[r2 + 1] = 0;
        r4 = r3 >> numDefine2;
        heapClassInst.heap32[r2 + numDefine2] = 0;
        r5 = heapClassInst.heap32[r4 + numDefine47];
        if (!(r5 < 1)) {
            r6 = gNumAlignedAllocs;
            r6 = r6 >> numDefine2;
            r7 = heapClassInst.heap32[r6];
            r8 = r5 << numDefine2;
            r7 = (r7 + 1) | 0;
            r8 = r8 | numDefine3;
            heapClassInst.heap32[r6] = r7;
            r6 = (r8 + numDefine16) | 0;
            heapClassInst.heap32[g0] = r6;
            mallocNew(i7);
            r6 = commonVariable.rg0;
            if (r6 != 0) {
                r7 = 0;
                r8 = (r6 + numDefine4) | 0;
                r7 = (r7 - r8) | 0;
                r7 = r7 & numDefine15;
                r7 = (r6 + r7) | 0;
                r8 = (r7 + numDefine4) | 0;
                r7 = r7 >> numDefine2;
                heapClassInst.heap32[r7] = r6;
                r6 = r8;
            }
            r7 = 1;
            heapClassInst.heap8[sp + numDefineNeg32] = (byte) r7;
            r7 = (r7 - r5) | 0;
            r8 = 0;
            heapClassInst.heap32[r2 + numDefine3] = r6;
            heapClassInst.heap32[r2 + numDefine2] = r5;
            repeat6:
            while (true) {
                r9 = r8 << numDefine2;
                r6 = (r6 - r9) | 0;
                r6 = r6 >> numDefine2;
                heapClassInst.heap32[r6] = 0;
                if (r7 == r8) {
                    break repeat6;
                } else {
                    r6 = heapClassInst.heap32[r2 + numDefine3];
                    r8 = (r8 + -1) | 0;
                    continue repeat6;
                }
            }
        }
        heapClassInst.heap32[r2 + 1] = r5;
        r5 = heapClassInst.heap32[r4];
        r5 = r5 >> numDefine2;
        r5 = heapClassInst.heap32[r5 + numDefine24];
        heapClassInst.heap32[g0] = r3;
        functionTable.get(r5 >> numDefine2).accept(i7);
        r5 = commonVariable.rg0;
        repeat10:
        do {
            if (!(r5 < 1)) {
                r5 = 0;
                repeat12:
                while (true) {
                    r6 = r5 << numDefine2;
                    r7 = heapClassInst.heap32[r4 + numDefine49];
                    r7 = (r7 + r6) | 0;
                    r7 = r7 >> numDefine2;
                    r8 = heapClassInst.heap32[r2 + numDefine3];
                    r6 = (r8 + r6) | 0;
                    r7 = heapClassInst.heap32[r7];
                    r6 = r6 >> numDefine2;
                    heapClassInst.heap32[r6] = r7;
                    r6 = heapClassInst.heap32[r4];
                    r6 = r6 >> numDefine2;
                    r6 = heapClassInst.heap32[r6 + numDefine24];
                    r5 = (r5 + 1) | 0;
                    heapClassInst.heap32[g0] = r3;
                    functionTable.get(r6 >> numDefine2).accept(i7);
                    r6 = commonVariable.rg0;
                    if (r6 > r5) {
                        continue repeat12;
                    } else {
                        break repeat10;
                    }
                }
            }
        } while (false);
        r5 = heapClassInst.heap32[r2 + 1];
        if (!(r5 < numDefine2)) {
            r5 = (r5 + -1) | 0;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = 0;
            heapClassInst.heap32[g0 + numDefine2] = r5;
            zn20btAlignedObjectArrayIP17btTypedConstraintE17quickSortInternalI33btSortConstraintOnIslandPredicateEEvTIi(i7);
        }
        r0 = heapClassInst.heap32[fp + 1];
        r5 = heapClassInst.heap32[r4];
        r5 = r5 >> numDefine2;
        r5 = heapClassInst.heap32[r5 + numDefine24];
        heapClassInst.heap32[g0] = r3;
        functionTable.get(r5 >> numDefine2).accept(i7);
        r3 = commonVariable.rg0;
        if (r3 != 0) {
            r3 = heapClassInst.heap32[r2 + numDefine3];
        } else {
            r3 = 0;
        }
        r5 = heapClassInst.heap32[r4 + numDefine6];
        r6 = heapClassInst.heap32[r4 + numDefine44];
        r7 = ztvzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback;
        r8 = heapClassInst.heap32[r4 + numDefine19];
        r9 = heapClassInst.heap32[r4 + numDefine21];
        r10 = heapClassInst.heap32[r2 + 1];
        r11 = sp + numDefineNeg144;
        r7 = (r7 + numDefine8) | 0;
        r12 = r11 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg36] = r7;
        heapClassInst.heap32[r12 + 1] = r0;
        heapClassInst.heap32[r12 + numDefine2] = r6;
        heapClassInst.heap32[r12 + numDefine3] = r3;
        heapClassInst.heap32[r12 + numDefine4] = r10;
        heapClassInst.heap32[r12 + numDefine5] = r9;
        heapClassInst.heap32[r12 + numDefine6] = r8;
        heapClassInst.heap32[r12 + numDefine7] = r5;
        heapClassInst.heap8[sp + numDefineNeg96] = (byte) r1;
        heapClassInst.heap32[r12 + numDefine11] = 0;
        heapClassInst.heap32[r12 + numDefine9] = 0;
        heapClassInst.heap32[r12 + numDefine10] = 0;
        heapClassInst.heap8[sp + numDefineNeg76] = (byte) r1;
        heapClassInst.heap32[r12 + numDefine16] = 0;
        heapClassInst.heap32[r12 + numDefine14] = 0;
        heapClassInst.heap32[r12 + numDefine15] = 0;
        heapClassInst.heap8[sp + numDefineNeg56] = (byte) r1;
        heapClassInst.heap32[r12 + numDefine21] = 0;
        heapClassInst.heap32[r12 + numDefine19] = 0;
        r3 = r6 >> numDefine2;
        heapClassInst.heap32[r12 + numDefine20] = 0;
        r6 = r5 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r6 = heapClassInst.heap32[r6];
        r3 = r3 >> numDefine2;
        r6 = r6 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine2];
        r6 = heapClassInst.heap32[r6 + numDefine9];
        heapClassInst.heap32[g0] = r5;
        functionTable.get(r6 >> numDefine2).accept(i7);
        r6 = heapClassInst.heap32[r4 + numDefine2];
        r8 = heapClassInst.heap32[r4 + numDefine44];
        heapClassInst.heap32[g0] = r8;
        heapClassInst.heap32[g0 + 1] = r6;
        heapClassInst.heap32[g0 + numDefine2] = commonVariable.rg0;
        functionTable.get(r3 >> numDefine2).accept(i7);
        r3 = heapClassInst.heap32[r4 + numDefine45];
        r5 = heapClassInst.heap32[r4 + numDefine6];
        r6 = twoEStr155;
        heapClassInst.heap32[g0] = r6;
        r6 = r3 >> numDefine2;
        zn15CProfileManager13StartProfileEPKc(i7);
        r8 = heapClassInst.heap32[r6 + numDefine7];
        repeat22:
        do {
            if (!(r8 > -1)) {
                r9 = heapClassInst.heap32[r6 + numDefine8];
                if (!(r9 > -1)) {
                    r9 = heapClassInst.heap32[r6 + numDefine9];
                    if (!(r9 == 0)) {
                        r10 = heapClassInst.heapU8[r3 + numDefine40];
                        if (!(r10 == 0)) {
                            r10 = gNumAlignedFree;
                            r10 = r10 >> numDefine2;
                            r13 = heapClassInst.heap32[r10];
                            r13 = (r13 + 1) | 0;
                            r9 = r9 >> numDefine2;
                            heapClassInst.heap32[r10] = r13;
                            r9 = heapClassInst.heap32[r9 + -1];
                            heapClassInst.heap32[g0] = r9;
                            free(i7);
                        }
                        heapClassInst.heap32[r6 + numDefine9] = 0;
                    }
                    r9 = 1;
                    heapClassInst.heap8[r3 + numDefine40] = (byte) r9;
                    heapClassInst.heap32[r6 + numDefine9] = 0;
                    heapClassInst.heap32[r6 + numDefine8] = 0;
                }
                repeat32:
                while (true) {
                    r9 = r8 << numDefine2;
                    r10 = heapClassInst.heap32[r6 + numDefine9];
                    r9 = (r10 + r9) | 0;
                    r8 = (r8 + 1) | 0;
                    r9 = r9 >> numDefine2;
                    heapClassInst.heap32[r9] = 0;
                    if (r8 != 0) {
                        continue repeat32;
                    } else {
                        break repeat22;
                    }
                }
            }
        } while (false);
        heapClassInst.heap32[r6 + numDefine7] = 0;
        r8 = heapClassInst.heap32[r6 + numDefine2];
        if (r8 > 0) {
            r9 = 0;
            repeat37:
            while (true) {
                r10 = heapClassInst.heap32[r6 + numDefine4];
                r13 = r9 << numDefine3;
                r13 = (r10 + r13) | 0;
                r13 = r13 >> numDefine2;
                r13 = heapClassInst.heap32[r13];
                r14 = r9 << 1;
                if (r9 == r13) {
                    r16 = r9;
                } else {
                    r15 = r10;
                    r16 = r9;
                    repeat42:
                    while (true) {
                        r13 = r13 << numDefine3;
                        r16 = r16 << numDefine3;
                        r13 = (r15 + r13) | 0;
                        r15 = (r15 + r16) | 0;
                        r13 = r13 >> numDefine2;
                        r15 = r15 >> numDefine2;
                        r16 = heapClassInst.heap32[r13];
                        heapClassInst.heap32[r15] = r16;
                        r16 = heapClassInst.heap32[r13];
                        r15 = heapClassInst.heap32[r6 + numDefine4];
                        r13 = r16 << numDefine3;
                        r13 = (r15 + r13) | 0;
                        r13 = r13 >> numDefine2;
                        r13 = heapClassInst.heap32[r13];
                        if (!(r13 != r16)) {
                            break repeat42;
                        }
                    }
                }
                r13 = r14 << numDefine2;
                r10 = (r10 + r13) | 0;
                r9 = (r9 + 1) | 0;
                r10 = r10 >> numDefine2;
                heapClassInst.heap32[r10] = r16;
                if (!(r8 != r9)) {
                    break repeat37;
                }
            }
            r8 = heapClassInst.heap32[r6 + numDefine2];
            if (r8 > 1) {
                r9 = (r3 + numDefine4) | 0;
                r8 = (r8 + -1) | 0;
                heapClassInst.heap32[g0] = r9;
                heapClassInst.heap32[g0 + 1] = 0;
                heapClassInst.heap32[g0 + numDefine2] = r8;
                zn20btAlignedObjectArrayI9btElementE17quickSortInternalI31btUnionFindElementSortPredicateEEvTIi(i7);
                r8 = heapClassInst.heap32[r6 + numDefine2];
            }
        }
        r9 = 0;
        repeat48:
        while (true) {
            r10 = r9;
            if (r10 < r8) {
                r13 = heapClassInst.heap32[r6 + numDefine4];
                r9 = r10 << numDefine3;
                r9 = (r13 + r9) | 0;
                r9 = r9 >> numDefine2;
                r14 = heapClassInst.heap32[r9];
                r15 = (r10 + 1) | 0;
                repeat51:
                while (true) {
                    r9 = r15;
                    if (r9 >= r8) {
                        break repeat51;
                    } else {
                        r15 = r9 << numDefine3;
                        r15 = (r13 + r15) | 0;
                        r16 = r15 >> numDefine2;
                        r15 = (r9 + 1) | 0;
                        r16 = heapClassInst.heap32[r16];
                        if (!(r16 == r14)) {
                            break repeat51;
                        }
                    }
                }
                r16 = 1;
                r15 = r10;
                repeat55:
                while (true) {
                    if (r15 < r9) {
                        r17 = r15 << numDefine3;
                        r17 = (r13 + r17) | 0;
                        r17 = r17 >> numDefine2;
                        r17 = heapClassInst.heap32[r17 + 1];
                        r18 = heapClassInst.heap32[r4 + numDefine4];
                        r17 = r17 << numDefine2;
                        r17 = (r18 + r17) | 0;
                        r17 = r17 >> numDefine2;
                        r17 = heapClassInst.heap32[r17];
                        r17 = r17 >> numDefine2;
                        r18 = heapClassInst.heap32[r17 + numDefine52];
                        if (r18 == r14) {
                            r17 = heapClassInst.heap32[r17 + numDefine54];
                            r18 = 0;
                            if (r17 == numDefine4) {
                                r16 = r18;
                            } else {
                                r16 = r17 == 1 ? r18 : r16;
                            }
                        } else {
                            if (r18 != -1) {
                                label = numDefine37;
                                break repeat48;
                            }
                        }
                        r15 = (r15 + 1) | 0;
                    } else {
                        break repeat55;
                    }
                }
                r13 = r16 & numDefine255;
                if (r13 == 0) {
                    repeat67:
                    while (true) {
                        if (r10 < r9) {
                            r13 = heapClassInst.heap32[r6 + numDefine4];
                            r15 = r10 << numDefine3;
                            r13 = (r13 + r15) | 0;
                            r13 = r13 >> numDefine2;
                            r13 = heapClassInst.heap32[r13 + 1];
                            r15 = heapClassInst.heap32[r4 + numDefine4];
                            r13 = r13 << numDefine2;
                            r13 = (r15 + r13) | 0;
                            r13 = r13 >> numDefine2;
                            r13 = heapClassInst.heap32[r13];
                            r13 = r13 >> numDefine2;
                            r15 = heapClassInst.heap32[r13 + numDefine52];
                            if (r15 == r14) {
                                r15 = heapClassInst.heap32[r13 + numDefine54];
                                if (!(r15 != numDefine2)) {
                                    heapClassInst.heap32[r13 + numDefine54] = numDefine3;
                                    heapClassInst.heap32[r13 + numDefine55] = 0;
                                }
                            } else {
                                if (!(r15 == -1)) {
                                    label = numDefine54;
                                    break repeat48;
                                }
                            }
                            r10 = (r10 + 1) | 0;
                            continue repeat67;
                        } else {
                            continue repeat48;
                        }
                    }
                } else {
                    repeat75:
                    while (true) {
                        if (r10 < r9) {
                            r13 = heapClassInst.heap32[r6 + numDefine4];
                            r15 = r10 << numDefine3;
                            r13 = (r13 + r15) | 0;
                            r13 = r13 >> numDefine2;
                            r13 = heapClassInst.heap32[r13 + 1];
                            r15 = heapClassInst.heap32[r4 + numDefine4];
                            r13 = r13 << numDefine2;
                            r13 = (r15 + r13) | 0;
                            r13 = r13 >> numDefine2;
                            r13 = heapClassInst.heap32[r13];
                            r13 = r13 >> numDefine2;
                            r15 = heapClassInst.heap32[r13 + numDefine52];
                            if (r15 == r14) {
                                r15 = heapClassInst.heap32[r13 + numDefine54];
                                r15 = (r15 + numDefineNeg4) | 0;
                                if (!(uint(r15) < uint(numDefine2))) {
                                    heapClassInst.heap32[r13 + numDefine54] = numDefine2;
                                }
                            } else {
                                if (!(r15 == -1)) {
                                    label = numDefine47;
                                    break repeat48;
                                }
                            }
                            r10 = (r10 + 1) | 0;
                            continue repeat75;
                        } else {
                            continue repeat48;
                        }
                    }
                }
            } else {
                label = numDefine60;
                break repeat48;
            }
        }
        switch (label) {
            case numDefine37:
                r0 = twoEStr1156;
                r1 = twoEStr2157;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine242;
                assertNew(i7);
                break;
            case numDefine54:
                r0 = twoEStr1156;
                r1 = twoEStr2157;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine290;
                assertNew(i7);
                break;
            case numDefine60:
                r8 = r5 >> numDefine2;
                r9 = heapClassInst.heap32[r8];
                r9 = r9 >> numDefine2;
                r9 = heapClassInst.heap32[r9 + numDefine9];
                heapClassInst.heap32[g0] = r5;
                functionTable.get(r9 >> numDefine2).accept(i7);
                r9 = commonVariable.rg0;
                repeat87:
                do {
                    if (!(r9 < 1)) {
                        r10 = 0;
                        repeat89:
                        while (true) {
                            r13 = heapClassInst.heap32[r8];
                            r13 = r13 >> numDefine2;
                            r13 = heapClassInst.heap32[r13 + numDefine10];
                            heapClassInst.heap32[g0] = r5;
                            heapClassInst.heap32[g0 + 1] = r10;
                            functionTable.get(r13 >> numDefine2).accept(i7);
                            r13 = commonVariable.rg0;
                            r14 = r13 >> numDefine2;
                            r15 = heapClassInst.heap32[r14 + numDefine277];
                            r14 = heapClassInst.heap32[r14 + numDefine278];
                            if (r15 == 0) {
                                label = numDefine64;
                            } else {
                                r16 = r15 >> numDefine2;
                                r16 = heapClassInst.heap32[r16 + numDefine54];
                                if (r16 != numDefine2) {
                                    label = numDefine66;
                                } else {
                                    label = numDefine64;
                                }
                            }
                            if (label == numDefine64) {
                                if (r14 == 0) {
                                    label = numDefine95;
                                } else {
                                    r16 = r14 >> numDefine2;
                                    r16 = heapClassInst.heap32[r16 + numDefine54];
                                    if (r16 == numDefine2) {
                                        label = numDefine95;
                                    } else {
                                        label = numDefine66;
                                    }
                                }
                            }
                            if (label == numDefine66) {
                                r16 = heapClassInst.heapU8[r15 + numDefine204];
                                r16 = r16 & numDefine2;
                                if (!(r16 == 0)) {
                                    r16 = r15 >> numDefine2;
                                    r16 = heapClassInst.heap32[r16 + numDefine54];
                                    if (!(r16 == numDefine2)) {
                                        r16 = heapClassInst.heapU8[r14 + numDefine204];
                                        r16 = r16 & numDefine3;
                                        if (!(r16 != 0)) {
                                            r16 = r14 >> numDefine2;
                                            r17 = heapClassInst.heap32[r16 + numDefine54];
                                            r17 = (r17 + numDefineNeg4) | 0;
                                            if (!(uint(r17) < uint(numDefine2))) {
                                                heapClassInst.heap32[r16 + numDefine54] = 1;
                                            }
                                            heapClassInst.heap32[r16 + numDefine55] = 0;
                                        }
                                    }
                                }
                                r16 = heapClassInst.heapU8[r14 + numDefine204];
                                r16 = r16 & numDefine2;
                                if (!(r16 == 0)) {
                                    r16 = r14 >> numDefine2;
                                    r16 = heapClassInst.heap32[r16 + numDefine54];
                                    if (!(r16 == numDefine2)) {
                                        r16 = heapClassInst.heapU8[r15 + numDefine204];
                                        r16 = r16 & numDefine3;
                                        if (!(r16 != 0)) {
                                            r16 = r15 >> numDefine2;
                                            r17 = heapClassInst.heap32[r16 + numDefine54];
                                            r17 = (r17 + numDefineNeg4) | 0;
                                            if (!(uint(r17) < uint(numDefine2))) {
                                                heapClassInst.heap32[r16 + numDefine54] = 1;
                                            }
                                            heapClassInst.heap32[r16 + numDefine55] = 0;
                                        }
                                    }
                                }
                                r16 = heapClassInst.heapU8[r3 + numDefine64];
                                if (!(r16 == 0)) {
                                    r16 = heapClassInst.heap32[r8];
                                    r16 = r16 >> numDefine2;
                                    r16 = heapClassInst.heap32[r16 + numDefine7];
                                    heapClassInst.heap32[g0] = r5;
                                    heapClassInst.heap32[g0 + 1] = r15;
                                    heapClassInst.heap32[g0 + numDefine2] = r14;
                                    functionTable.get(r16 >> numDefine2).accept(i7);
                                    r14 = commonVariable.rg0;
                                    if (!(r14 == 0)) {
                                        r14 = heapClassInst.heap32[r6 + numDefine8];
                                        r15 = heapClassInst.heap32[r6 + numDefine7];
                                        if (r14 == r15) {
                                            r16 = 1;
                                            r17 = r15 << 1;
                                            r17 = r15 == 0 ? r16 : r17;
                                            if (!(r14 >= r17)) {
                                                if (r17 != 0) {
                                                    r14 = gNumAlignedAllocs;
                                                    r14 = r14 >> numDefine2;
                                                    r18 = heapClassInst.heap32[r14];
                                                    r19 = r17 << numDefine2;
                                                    r18 = (r18 + 1) | 0;
                                                    r19 = r19 | numDefine3;
                                                    heapClassInst.heap32[r14] = r18;
                                                    r14 = (r19 + numDefine16) | 0;
                                                    heapClassInst.heap32[g0] = r14;
                                                    mallocNew(i7);
                                                    r14 = commonVariable.rg0;
                                                    if (r14 != 0) {
                                                        r15 = 0;
                                                        r18 = (r14 + numDefine4) | 0;
                                                        r15 = (r15 - r18) | 0;
                                                        r15 = r15 & numDefine15;
                                                        r15 = (r14 + r15) | 0;
                                                        r18 = r15 >> numDefine2;
                                                        heapClassInst.heap32[r18] = r14;
                                                        r14 = (r15 + numDefine4) | 0;
                                                        r15 = heapClassInst.heap32[r6 + numDefine7];
                                                    }
                                                } else {
                                                    r14 = 0;
                                                }
                                                if (!(r15 < 1)) {
                                                    r18 = 0;
                                                    repeat126:
                                                    while (true) {
                                                        r19 = r18 << numDefine2;
                                                        r20 = heapClassInst.heap32[r6 + numDefine9];
                                                        r20 = (r20 + r19) | 0;
                                                        r20 = r20 >> numDefine2;
                                                        r19 = (r14 + r19) | 0;
                                                        r20 = heapClassInst.heap32[r20];
                                                        r18 = (r18 + 1) | 0;
                                                        r19 = r19 >> numDefine2;
                                                        heapClassInst.heap32[r19] = r20;
                                                        if (!(r15 != r18)) {
                                                            break repeat126;
                                                        }
                                                    }
                                                }
                                                r15 = heapClassInst.heap32[r6 + numDefine9];
                                                if (!(r15 == 0)) {
                                                    r18 = heapClassInst.heapU8[r3 + numDefine40];
                                                    if (!(r18 == 0)) {
                                                        r18 = gNumAlignedFree;
                                                        r18 = r18 >> numDefine2;
                                                        r19 = heapClassInst.heap32[r18];
                                                        r19 = (r19 + 1) | 0;
                                                        r15 = r15 >> numDefine2;
                                                        heapClassInst.heap32[r18] = r19;
                                                        r15 = heapClassInst.heap32[r15 + -1];
                                                        heapClassInst.heap32[g0] = r15;
                                                        free(i7);
                                                    }
                                                    heapClassInst.heap32[r6 + numDefine9] = 0;
                                                }
                                                heapClassInst.heap8[r3 + numDefine40] = (byte) r16;
                                                heapClassInst.heap32[r6 + numDefine9] = r14;
                                                heapClassInst.heap32[r6 + numDefine8] = r17;
                                                r15 = heapClassInst.heap32[r6 + numDefine7];
                                            }
                                        }
                                        r14 = r15 << numDefine2;
                                        r15 = heapClassInst.heap32[r6 + numDefine9];
                                        r14 = (r15 + r14) | 0;
                                        r14 = r14 >> numDefine2;
                                        heapClassInst.heap32[r14] = r13;
                                        r13 = heapClassInst.heap32[r6 + numDefine7];
                                        r13 = (r13 + 1) | 0;
                                        heapClassInst.heap32[r6 + numDefine7] = r13;
                                    }
                                }
                            }
                            r10 = (r10 + 1) | 0;
                            if (r9 != r10) {
                                continue repeat89;
                            } else {
                                break repeat87;
                            }
                        }
                    }
                } while (false);
                r9 = zn15CProfileManager11CurrentNodeE;
                r9 = r9 >> numDefine2;
                r10 = heapClassInst.heap32[r9];
                r13 = r10 >> numDefine2;
                r14 = heapClassInst.heap32[r13 + numDefine4];
                r14 = (r14 + -1) | 0;
                heapClassInst.heap32[r13 + numDefine4] = r14;
                repeat138:
                do {
                    if (!(r14 != 0)) {
                        r14 = heapClassInst.heap32[r13 + 1];
                        if (r14 != 0) {
                            r10 = sp + numDefineNeg24;
                            heapClassInst.heap32[g0] = r10;
                            heapClassInst.heap32[g0 + 1] = 0;
                            r14 = zl13gProfileClock2E0;
                            getTimeOfDay(i7);
                            r14 = r14 >> numDefine2;
                            r14 = heapClassInst.heap32[r14];
                            r14 = r14 >> numDefine2;
                            r10 = r10 >> numDefine2;
                            r15 = heapClassInst.heap32[fp + numDefineNeg6];
                            r16 = heapClassInst.heap32[r14];
                            r15 = (r15 - r16) | 0;
                            r10 = heapClassInst.heap32[r10 + 1];
                            r14 = heapClassInst.heap32[r14 + 1];
                            r10 = (r10 - r14) | 0;
                            r14 = (int) ((r15 * numDefineN6) | 0);
                            r10 = (r10 + r14) | 0;
                            r14 = heapClassInst.heap32[r13 + numDefine3];
                            r10 = (r10 - r14) | 0;
                            f0 = uint(r10);
                            f1 = numDefine1000;
                            f2 = heapClassInst.heapFloat[r13 + numDefine2];
                            f0 = f0 / f1;
                            f0 = f2 + f0;
                            heapClassInst.heapFloat[r13 + numDefine2] = f0;
                            r10 = heapClassInst.heap32[r13 + numDefine4];
                            if (r10 != 0) {
                                break repeat138;
                            } else {
                                r10 = heapClassInst.heap32[r9];
                            }
                        }
                        r10 = r10 >> numDefine2;
                        r10 = heapClassInst.heap32[r10 + numDefine5];
                        heapClassInst.heap32[r9] = r10;
                    }
                } while (false);
                r10 = heapClassInst.heap32[r6 + numDefine2];
                r13 = twoEStr3158;
                heapClassInst.heap32[g0] = r13;
                zn15CProfileManager13StartProfileEPKc(i7);
                r13 = heapClassInst.heapU8[r3 + numDefine64];
                repeat145:
                do {
                    if (r13 != 0) {
                        r5 = heapClassInst.heap32[r6 + numDefine7];
                        if (!(r5 < numDefine2)) {
                            r8 = (r3 + numDefine24) | 0;
                            r13 = (r5 + -1) | 0;
                            heapClassInst.heap32[g0] = r8;
                            heapClassInst.heap32[g0 + 1] = 0;
                            heapClassInst.heap32[g0 + numDefine2] = r13;
                            zn20btAlignedObjectArrayIP20btPersistentManifoldE17quickSortInternalI33btPersistentManifoldSortPredicateEEvTIi(i7);
                        }
                        if (!(r10 < 1)) {
                            r8 = 0;
                            r13 = r8;
                            r14 = r8;
                            repeat151:
                            while (true) {
                                r15 = heapClassInst.heap32[r6 + numDefine4];
                                r16 = r14 << numDefine3;
                                r15 = (r15 + r16) | 0;
                                r15 = r15 >> numDefine2;
                                r15 = heapClassInst.heap32[r15];
                                r16 = r8;
                                repeat153:
                                while (true) {
                                    if (r14 >= r10) {
                                        break repeat153;
                                    } else {
                                        r17 = heapClassInst.heap32[r6 + numDefine4];
                                        r18 = r14 << numDefine3;
                                        r17 = (r17 + r18) | 0;
                                        r17 = r17 >> numDefine2;
                                        r18 = heapClassInst.heap32[r17];
                                        if (r18 == r15) {
                                            r17 = heapClassInst.heap32[r17 + 1];
                                            r18 = heapClassInst.heap32[r4 + numDefine4];
                                            r17 = r17 << numDefine2;
                                            r17 = (r18 + r17) | 0;
                                            r17 = r17 >> numDefine2;
                                            r18 = heapClassInst.heap32[r6 + numDefine13];
                                            r19 = heapClassInst.heap32[r6 + numDefine12];
                                            r17 = heapClassInst.heap32[r17];
                                            if (r18 == r19) {
                                                r20 = 1;
                                                r21 = r19 << 1;
                                                r21 = r19 == 0 ? r20 : r21;
                                                if (!(r18 >= r21)) {
                                                    if (r21 != 0) {
                                                        r18 = gNumAlignedAllocs;
                                                        r18 = r18 >> numDefine2;
                                                        r22 = heapClassInst.heap32[r18];
                                                        r23 = r21 << numDefine2;
                                                        r22 = (r22 + 1) | 0;
                                                        r23 = r23 | numDefine3;
                                                        heapClassInst.heap32[r18] = r22;
                                                        r18 = (r23 + numDefine16) | 0;
                                                        heapClassInst.heap32[g0] = r18;
                                                        mallocNew(i7);
                                                        r18 = commonVariable.rg0;
                                                        if (r18 != 0) {
                                                            r19 = 0;
                                                            r22 = (r18 + numDefine4) | 0;
                                                            r19 = (r19 - r22) | 0;
                                                            r19 = r19 & numDefine15;
                                                            r19 = (r18 + r19) | 0;
                                                            r22 = r19 >> numDefine2;
                                                            heapClassInst.heap32[r22] = r18;
                                                            r18 = (r19 + numDefine4) | 0;
                                                            r19 = heapClassInst.heap32[r6 + numDefine12];
                                                        }
                                                    } else {
                                                        r18 = 0;
                                                    }
                                                    if (!(r19 < 1)) {
                                                        r22 = 0;
                                                        repeat167:
                                                        while (true) {
                                                            r23 = r22 << numDefine2;
                                                            r24 = heapClassInst.heap32[r6 + numDefine14];
                                                            r24 = (r24 + r23) | 0;
                                                            r24 = r24 >> numDefine2;
                                                            r23 = (r18 + r23) | 0;
                                                            r24 = heapClassInst.heap32[r24];
                                                            r22 = (r22 + 1) | 0;
                                                            r23 = r23 >> numDefine2;
                                                            heapClassInst.heap32[r23] = r24;
                                                            if (!(r19 != r22)) {
                                                                break repeat167;
                                                            }
                                                        }
                                                    }
                                                    r19 = heapClassInst.heap32[r6 + numDefine14];
                                                    if (!(r19 == 0)) {
                                                        r22 = heapClassInst.heapU8[r3 + numDefine60];
                                                        if (!(r22 == 0)) {
                                                            r22 = gNumAlignedFree;
                                                            r22 = r22 >> numDefine2;
                                                            r23 = heapClassInst.heap32[r22];
                                                            r23 = (r23 + 1) | 0;
                                                            r19 = r19 >> numDefine2;
                                                            heapClassInst.heap32[r22] = r23;
                                                            r19 = heapClassInst.heap32[r19 + -1];
                                                            heapClassInst.heap32[g0] = r19;
                                                            free(i7);
                                                        }
                                                        heapClassInst.heap32[r6 + numDefine14] = 0;
                                                    }
                                                    heapClassInst.heap8[r3 + numDefine60] = (byte) r20;
                                                    heapClassInst.heap32[r6 + numDefine14] = r18;
                                                    heapClassInst.heap32[r6 + numDefine13] = r21;
                                                    r19 = heapClassInst.heap32[r6 + numDefine12];
                                                }
                                            }
                                            r18 = r19 << numDefine2;
                                            r19 = heapClassInst.heap32[r6 + numDefine14];
                                            r18 = (r19 + r18) | 0;
                                            r18 = r18 >> numDefine2;
                                            heapClassInst.heap32[r18] = r17;
                                            r18 = heapClassInst.heap32[r6 + numDefine12];
                                            r18 = (r18 + 1) | 0;
                                            r17 = r17 >> numDefine2;
                                            heapClassInst.heap32[r6 + numDefine12] = r18;
                                            r17 = heapClassInst.heap32[r17 + numDefine54];
                                            if (r17 != numDefine2) {
                                                r18 = 1;
                                                r16 = r17 == numDefine5 ? r18 : r16;
                                            } else {
                                                r16 = 1;
                                            }
                                            r14 = (r14 + 1) | 0;
                                        } else {
                                            break repeat153;
                                        }
                                    }
                                }
                                repeat182:
                                do {
                                    if (r13 < r5) {
                                        r17 = heapClassInst.heap32[r6 + numDefine9];
                                        r19 = r13 << numDefine2;
                                        r18 = (r17 + r19) | 0;
                                        r20 = r18 >> numDefine2;
                                        r20 = heapClassInst.heap32[r20];
                                        r20 = r20 >> numDefine2;
                                        r21 = heapClassInst.heap32[r20 + numDefine277];
                                        r21 = r21 >> numDefine2;
                                        r21 = heapClassInst.heap32[r21 + numDefine52];
                                        if (r21 < 0) {
                                            r21 = heapClassInst.heap32[r20 + numDefine278];
                                            r21 = r21 >> numDefine2;
                                            r21 = heapClassInst.heap32[r21 + numDefine52];
                                        }
                                        if (r21 != r15) {
                                            label = numDefine129;
                                        } else {
                                            r19 = (r17 + r19) | 0;
                                            r20 = 1;
                                            while (true) {
                                                r17 = r20;
                                                r1 = (r13 + r17) | 0;
                                                if (r1 >= r5) {
                                                    label = numDefine138;
                                                    break repeat182;
                                                } else {
                                                    r20 = r17 << numDefine2;
                                                    r20 = (r19 + r20) | 0;
                                                    r20 = r20 >> numDefine2;
                                                    r20 = heapClassInst.heap32[r20];
                                                    r20 = r20 >> numDefine2;
                                                    r21 = heapClassInst.heap32[r20 + numDefine277];
                                                    r21 = r21 >> numDefine2;
                                                    r21 = heapClassInst.heap32[r21 + numDefine52];
                                                    if (r21 < 0) {
                                                        r20 = heapClassInst.heap32[r20 + numDefine278];
                                                        r20 = r20 >> numDefine2;
                                                        r21 = heapClassInst.heap32[r20 + numDefine52];
                                                    }
                                                    r20 = (r17 + 1) | 0;
                                                    if (!(r21 == r15)) {
                                                        label = numDefine138;
                                                        break repeat182;
                                                    }
                                                }
                                            }
                                        }
                                    } else {
                                        label = numDefine129;
                                    }
                                } while (false);
                                if (label == numDefine129) {
                                    r17 = 0;
                                    r18 = r17;
                                }
                                r16 = r16 & numDefine255;
                                if (!(r16 != 0)) {
                                    r16 = heapClassInst.heap32[fp + numDefineNeg36];
                                    r16 = r16 >> numDefine2;
                                    r16 = heapClassInst.heap32[r16 + numDefine2];
                                    r19 = heapClassInst.heap32[r6 + numDefine12];
                                    r20 = heapClassInst.heap32[r6 + numDefine14];
                                    heapClassInst.heap32[g0] = r11;
                                    heapClassInst.heap32[g0 + 1] = r20;
                                    heapClassInst.heap32[g0 + numDefine2] = r19;
                                    heapClassInst.heap32[g0 + numDefine3] = r18;
                                    heapClassInst.heap32[g0 + numDefine4] = r17;
                                    heapClassInst.heap32[g0 + numDefine5] = r15;
                                    functionTable.get(r16 >> numDefine2).accept(i7);
                                }
                                r15 = heapClassInst.heap32[r6 + numDefine12];
                                repeat200:
                                do {
                                    if (!(r15 > -1)) {
                                        r16 = heapClassInst.heap32[r6 + numDefine13];
                                        if (r16 < 0) {
                                            r16 = heapClassInst.heap32[r6 + numDefine14];
                                            if (!(r16 == 0)) {
                                                r18 = heapClassInst.heapU8[r3 + numDefine60];
                                                if (!(r18 == 0)) {
                                                    r18 = gNumAlignedFree;
                                                    r18 = r18 >> numDefine2;
                                                    r19 = heapClassInst.heap32[r18];
                                                    r19 = (r19 + 1) | 0;
                                                    r16 = r16 >> numDefine2;
                                                    heapClassInst.heap32[r18] = r19;
                                                    r16 = heapClassInst.heap32[r16 + -1];
                                                    heapClassInst.heap32[g0] = r16;
                                                    free(i7);
                                                }
                                                heapClassInst.heap32[r6 + numDefine14] = 0;
                                            }
                                            r16 = 1;
                                            heapClassInst.heap8[r3 + numDefine60] = (byte) r16;
                                            heapClassInst.heap32[r6 + numDefine14] = 0;
                                            heapClassInst.heap32[r6 + numDefine13] = 0;
                                        }
                                        while (true) {
                                            r16 = r15 << numDefine2;
                                            r18 = heapClassInst.heap32[r6 + numDefine14];
                                            r16 = (r18 + r16) | 0;
                                            r15 = (r15 + 1) | 0;
                                            r16 = r16 >> numDefine2;
                                            heapClassInst.heap32[r16] = 0;
                                            if (!(r15 != 0)) {
                                                break repeat200;
                                            }
                                        }
                                    }
                                } while (false);
                                r13 = r17 == 0 ? r13 : r1;
                                heapClassInst.heap32[r6 + numDefine12] = 0;
                                if (r14 < r10) {
                                    continue repeat151;
                                } else {
                                    break repeat145;
                                }
                            }
                        }
                    } else {
                        r1 = heapClassInst.heap32[r8];
                        r1 = r1 >> numDefine2;
                        r1 = heapClassInst.heap32[r1 + numDefine11];
                        heapClassInst.heap32[g0] = r5;
                        functionTable.get(r1 >> numDefine2).accept(i7);
                        r1 = commonVariable.rg0;
                        r3 = heapClassInst.heap32[r8];
                        r3 = r3 >> numDefine2;
                        r3 = heapClassInst.heap32[r3 + numDefine9];
                        heapClassInst.heap32[g0] = r5;
                        functionTable.get(r3 >> numDefine2).accept(i7);
                        r6 = heapClassInst.heap32[fp + numDefineNeg36];
                        r6 = r6 >> numDefine2;
                        r6 = heapClassInst.heap32[r6 + numDefine2];
                        r10 = heapClassInst.heap32[r4 + numDefine2];
                        r5 = heapClassInst.heap32[r4 + numDefine4];
                        heapClassInst.heap32[g0] = r11;
                        heapClassInst.heap32[g0 + 1] = r5;
                        heapClassInst.heap32[g0 + numDefine2] = r10;
                        heapClassInst.heap32[g0 + numDefine3] = r1;
                        heapClassInst.heap32[g0 + numDefine4] = commonVariable.rg0;
                        heapClassInst.heap32[g0 + numDefine5] = -1;
                        functionTable.get(r6 >> numDefine2).accept(i7);
                    }
                } while (false);
                r1 = heapClassInst.heap32[r9];
                r3 = r1 >> numDefine2;
                r5 = heapClassInst.heap32[r3 + numDefine4];
                r5 = (r5 + -1) | 0;
                heapClassInst.heap32[r3 + numDefine4] = r5;
                repeat215:
                do {
                    if (!(r5 != 0)) {
                        r5 = heapClassInst.heap32[r3 + 1];
                        if (r5 != 0) {
                            r1 = sp + numDefineNeg16;
                            heapClassInst.heap32[g0] = r1;
                            heapClassInst.heap32[g0 + 1] = 0;
                            r5 = zl13gProfileClock2E0;
                            getTimeOfDay(i7);
                            r5 = r5 >> numDefine2;
                            r5 = heapClassInst.heap32[r5];
                            r5 = r5 >> numDefine2;
                            r1 = r1 >> numDefine2;
                            r6 = heapClassInst.heap32[fp + numDefineNeg4];
                            r8 = heapClassInst.heap32[r5];
                            r6 = (r6 - r8) | 0;
                            r1 = heapClassInst.heap32[r1 + 1];
                            r5 = heapClassInst.heap32[r5 + 1];
                            r1 = (r1 - r5) | 0;
                            r5 = (int) ((r6 * numDefineN6) | 0);
                            r1 = (r1 + r5) | 0;
                            r5 = heapClassInst.heap32[r3 + numDefine3];
                            r1 = (r1 - r5) | 0;
                            f0 = uint(r1);
                            f1 = numDefine1000;
                            f2 = heapClassInst.heapFloat[r3 + numDefine2];
                            f0 = f0 / f1;
                            f0 = f2 + f0;
                            heapClassInst.heapFloat[r3 + numDefine2] = f0;
                            r1 = heapClassInst.heap32[r3 + numDefine4];
                            if (r1 != 0) {
                                break repeat215;
                            } else {
                                r1 = heapClassInst.heap32[r9];
                            }
                        }
                        r1 = r1 >> numDefine2;
                        r1 = heapClassInst.heap32[r1 + numDefine5];
                        heapClassInst.heap32[r9] = r1;
                    }
                } while (false);
                heapClassInst.heap32[g0] = r11;
                zzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoEN27InplaceSolverIslandCallback18processConstraintsEv(i7);
                r1 = heapClassInst.heap32[r4 + numDefine44];
                r3 = r1 >> numDefine2;
                r3 = heapClassInst.heap32[r3];
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3 + numDefine4];
                r5 = heapClassInst.heap32[r4 + numDefine19];
                r4 = heapClassInst.heap32[r4 + numDefine21];
                heapClassInst.heap32[g0] = r1;
                heapClassInst.heap32[g0 + 1] = r0;
                heapClassInst.heap32[g0 + numDefine2] = r4;
                heapClassInst.heap32[g0 + numDefine3] = r5;
                functionTable.get(r3 >> numDefine2).accept(i7);
                heapClassInst.heap32[fp + numDefineNeg36] = r7;
                r0 = heapClassInst.heap32[r12 + numDefine21];
                if (!(r0 == 0)) {
                    r1 = heapClassInst.heapU8[sp + numDefineNeg56];
                    if (!(r1 == 0)) {
                        r1 = gNumAlignedFree;
                        r1 = r1 >> numDefine2;
                        r3 = heapClassInst.heap32[r1];
                        r3 = (r3 + 1) | 0;
                        r0 = r0 >> numDefine2;
                        heapClassInst.heap32[r1] = r3;
                        r0 = heapClassInst.heap32[r0 + -1];
                        heapClassInst.heap32[g0] = r0;
                        free(i7);
                    }
                    heapClassInst.heap32[r12 + numDefine21] = 0;
                }
                r0 = 1;
                heapClassInst.heap8[sp + numDefineNeg56] = (byte) r0;
                heapClassInst.heap32[r12 + numDefine21] = 0;
                heapClassInst.heap32[r12 + numDefine19] = 0;
                heapClassInst.heap32[r12 + numDefine20] = 0;
                r1 = heapClassInst.heap32[r12 + numDefine16];
                if (!(r1 == 0)) {
                    r3 = heapClassInst.heapU8[sp + numDefineNeg76];
                    if (!(r3 == 0)) {
                        r3 = gNumAlignedFree;
                        r3 = r3 >> numDefine2;
                        r4 = heapClassInst.heap32[r3];
                        r4 = (r4 + 1) | 0;
                        r1 = r1 >> numDefine2;
                        heapClassInst.heap32[r3] = r4;
                        r1 = heapClassInst.heap32[r1 + -1];
                        heapClassInst.heap32[g0] = r1;
                        free(i7);
                    }
                    heapClassInst.heap32[r12 + numDefine16] = 0;
                }
                heapClassInst.heap8[sp + numDefineNeg76] = (byte) r0;
                heapClassInst.heap32[r12 + numDefine16] = 0;
                heapClassInst.heap32[r12 + numDefine14] = 0;
                heapClassInst.heap32[r12 + numDefine15] = 0;
                r1 = heapClassInst.heap32[r12 + numDefine11];
                if (!(r1 == 0)) {
                    r3 = heapClassInst.heapU8[sp + numDefineNeg96];
                    if (!(r3 == 0)) {
                        r3 = gNumAlignedFree;
                        r3 = r3 >> numDefine2;
                        r4 = heapClassInst.heap32[r3];
                        r4 = (r4 + 1) | 0;
                        r1 = r1 >> numDefine2;
                        heapClassInst.heap32[r3] = r4;
                        r1 = heapClassInst.heap32[r1 + -1];
                        heapClassInst.heap32[g0] = r1;
                        free(i7);
                    }
                    heapClassInst.heap32[r12 + numDefine11] = 0;
                }
                heapClassInst.heap8[sp + numDefineNeg96] = (byte) r0;
                heapClassInst.heap32[r12 + numDefine11] = 0;
                heapClassInst.heap32[r12 + numDefine9] = 0;
                heapClassInst.heap32[r12 + numDefine10] = 0;
                r1 = heapClassInst.heap32[r2 + numDefine3];
                if (!(r1 == 0)) {
                    r3 = heapClassInst.heapU8[sp + numDefineNeg32];
                    if (!(r3 == 0)) {
                        r3 = gNumAlignedFree;
                        r3 = r3 >> numDefine2;
                        r4 = heapClassInst.heap32[r3];
                        r4 = (r4 + 1) | 0;
                        r1 = r1 >> numDefine2;
                        heapClassInst.heap32[r3] = r4;
                        r1 = heapClassInst.heap32[r1 + -1];
                        heapClassInst.heap32[g0] = r1;
                        free(i7);
                    }
                    heapClassInst.heap32[r2 + numDefine3] = 0;
                }
                heapClassInst.heap8[sp + numDefineNeg32] = (byte) r0;
                heapClassInst.heap32[r2 + numDefine3] = 0;
                heapClassInst.heap32[r2 + 1] = 0;
                heapClassInst.heap32[r2 + numDefine2] = 0;
                r0 = heapClassInst.heap32[r9];
                r1 = r0 >> numDefine2;
                r2 = heapClassInst.heap32[r1 + numDefine4];
                r2 = (r2 + -1) | 0;
                heapClassInst.heap32[r1 + numDefine4] = r2;
                repeat246:
                do {
                    if (!(r2 != 0)) {
                        r2 = heapClassInst.heap32[r1 + 1];
                        if (r2 != 0) {
                            r0 = sp + numDefineNeg8;
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = 0;
                            r2 = zl13gProfileClock2E0;
                            getTimeOfDay(i7);
                            r2 = r2 >> numDefine2;
                            r2 = heapClassInst.heap32[r2];
                            r2 = r2 >> numDefine2;
                            r0 = r0 >> numDefine2;
                            r3 = heapClassInst.heap32[fp + numDefineNeg2];
                            r4 = heapClassInst.heap32[r2];
                            r3 = (r3 - r4) | 0;
                            r0 = heapClassInst.heap32[r0 + 1];
                            r2 = heapClassInst.heap32[r2 + 1];
                            r0 = (r0 - r2) | 0;
                            r2 = (int) ((r3 * numDefineN6) | 0);
                            r0 = (r0 + r2) | 0;
                            r2 = heapClassInst.heap32[r1 + numDefine3];
                            r0 = (r0 - r2) | 0;
                            f0 = uint(r0);
                            f1 = numDefine1000;
                            f2 = heapClassInst.heapFloat[r1 + numDefine2];
                            f0 = f0 / f1;
                            f0 = f2 + f0;
                            heapClassInst.heapFloat[r1 + numDefine2] = f0;
                            r0 = heapClassInst.heap32[r1 + numDefine4];
                            if (r0 != 0) {
                                break repeat246;
                            } else {
                                r0 = heapClassInst.heap32[r9];
                            }
                        }
                        r0 = r0 >> numDefine2;
                        r0 = heapClassInst.heap32[r0 + numDefine5];
                        heapClassInst.heap32[r9] = r0;
                    }
                } while (false);
                
            case numDefine47:
                r0 = twoEStr1156;
                r1 = twoEStr2157;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine269;
                assertNew(i7);
                break;
            default:
                break;
        }
        
    }

    public static void zn23btDiscreteDynamicsWorld16removeConstraintEP17btTypedConstraint(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heap32[r0 + numDefine47];
        r3 = 0;
        repeat1:
        while (true) {
            if (r2 > r3) {
                r4 = heapClassInst.heap32[r0 + numDefine49];
                r5 = r3 << numDefine2;
                r4 = (r4 + r5) | 0;
                r4 = r4 >> numDefine2;
                r4 = heapClassInst.heap32[r4];
                if (r4 != r1) {
                    r3 = (r3 + 1) | 0;
                    continue repeat1;
                } else {
                    label = numDefine5;
                    break repeat1;
                }
            } else {
                label = numDefine4;
                break repeat1;
            }
        }
        if (label == numDefine4) {
            r3 = r2;
        }
        if (!(r2 <= r3)) {
            r2 = (r2 + -1) | 0;
            r3 = r3 << numDefine2;
            r4 = heapClassInst.heap32[r0 + numDefine49];
            r2 = r2 << numDefine2;
            r3 = (r4 + r3) | 0;
            r4 = (r4 + r2) | 0;
            r3 = r3 >> numDefine2;
            r4 = r4 >> numDefine2;
            r5 = heapClassInst.heap32[r3];
            r4 = heapClassInst.heap32[r4];
            heapClassInst.heap32[r3] = r4;
            r3 = heapClassInst.heap32[r0 + numDefine49];
            r2 = (r3 + r2) | 0;
            r2 = r2 >> numDefine2;
            heapClassInst.heap32[r2] = r5;
            r2 = heapClassInst.heap32[r0 + numDefine47];
            r2 = (r2 + -1) | 0;
            heapClassInst.heap32[r0 + numDefine47] = r2;
        }
        r0 = r1 >> numDefine2;
        r2 = heapClassInst.heap32[r0 + numDefine5];
        r2 = r2 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + numDefine120];
        r4 = 0;
        repeat11:
        while (true) {
            if (r3 > r4) {
                r5 = heapClassInst.heap32[r2 + numDefine122];
                r6 = r4 << numDefine2;
                r5 = (r5 + r6) | 0;
                r5 = r5 >> numDefine2;
                r5 = heapClassInst.heap32[r5];
                if (r5 != r1) {
                    r4 = (r4 + 1) | 0;
                    continue repeat11;
                } else {
                    label = numDefine12;
                    break repeat11;
                }
            } else {
                label = numDefine11;
                break repeat11;
            }
        }
        if (label == numDefine11) {
            r4 = r3;
        }
        if (r3 > r4) {
            r3 = (r3 + -1) | 0;
            r4 = r4 << numDefine2;
            r5 = heapClassInst.heap32[r2 + numDefine122];
            r3 = r3 << numDefine2;
            r4 = (r5 + r4) | 0;
            r5 = (r5 + r3) | 0;
            r4 = r4 >> numDefine2;
            r5 = r5 >> numDefine2;
            r6 = heapClassInst.heap32[r4];
            r5 = heapClassInst.heap32[r5];
            heapClassInst.heap32[r4] = r5;
            r4 = heapClassInst.heap32[r2 + numDefine122];
            r3 = (r4 + r3) | 0;
            r3 = r3 >> numDefine2;
            heapClassInst.heap32[r3] = r6;
            r3 = heapClassInst.heap32[r2 + numDefine120];
            r3 = (r3 + -1) | 0;
            heapClassInst.heap32[r2 + numDefine120] = r3;
        }
        r4 = 0;

        r3 = r3 > r4 ? 1 : 0;
        r3 = r3 & 1;
        heapClassInst.heap32[r2 + numDefine63] = r3;
        r0 = heapClassInst.heap32[r0 + numDefine6];
        r0 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r0 + numDefine120];
        repeat21:
        while (true) {
            if (r2 > r4) {
                r3 = heapClassInst.heap32[r0 + numDefine122];
                r5 = r4 << numDefine2;
                r3 = (r3 + r5) | 0;
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3];
                if (r3 != r1) {
                    r4 = (r4 + 1) | 0;
                    continue repeat21;
                } else {
                    label = numDefine19;
                    break repeat21;
                }
            } else {
                label = numDefine18;
                break repeat21;
            }
        }
        if (label == numDefine18) {
            r4 = r2;
        }
        if (r2 > r4) {
            r2 = (r2 + -1) | 0;
            r1 = r4 << numDefine2;
            r3 = heapClassInst.heap32[r0 + numDefine122];
            r2 = r2 << numDefine2;
            r1 = (r3 + r1) | 0;
            r3 = (r3 + r2) | 0;
            r1 = r1 >> numDefine2;
            r3 = r3 >> numDefine2;
            r4 = heapClassInst.heap32[r1];
            r3 = heapClassInst.heap32[r3];
            heapClassInst.heap32[r1] = r3;
            r1 = heapClassInst.heap32[r0 + numDefine122];
            r2 = (r1 + r2) | 0;
            r2 = r2 >> numDefine2;
            heapClassInst.heap32[r2] = r4;
            r2 = heapClassInst.heap32[r0 + numDefine120];
            r2 = (r2 + -1) | 0;
            heapClassInst.heap32[r0 + numDefine120] = r2;
        }
        r1 = 0;

        r1 = r2 > r1 ? 1 : 0;
        r1 = r1 & 1;
        heapClassInst.heap32[r0 + numDefine63] = r1;
        
    }

    public static void zn23btDiscreteDynamicsWorld13addConstraintEP17btTypedConstraintb(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine48];
        r3 = heapClassInst.heap32[r1 + numDefine47];
        r4 = heapClassInst.heap32[fp + 1];
        r5 = heapClassInst.heap32[fp + numDefine2];
        if (r2 == r3) {
            r6 = 1;
            r7 = r3 << 1;
            r7 = r3 == 0 ? r6 : r7;
            if (!(r2 >= r7)) {
                if (r7 != 0) {
                    r2 = gNumAlignedAllocs;
                    r2 = r2 >> numDefine2;
                    r8 = heapClassInst.heap32[r2];
                    r9 = r7 << numDefine2;
                    r8 = (r8 + 1) | 0;
                    r9 = r9 | numDefine3;
                    heapClassInst.heap32[r2] = r8;
                    r2 = (r9 + numDefine16) | 0;
                    heapClassInst.heap32[g0] = r2;
                    mallocNew(i7);
                    r2 = commonVariable.rg0;
                    if (r2 != 0) {
                        r8 = 0;
                        r9 = (r2 + numDefine4) | 0;
                        r8 = (r8 - r9) | 0;
                        r8 = r8 & numDefine15;
                        r8 = (r2 + r8) | 0;
                        r9 = (r8 + numDefine4) | 0;
                        r8 = r8 >> numDefine2;
                        heapClassInst.heap32[r8] = r2;
                        r2 = r9;
                    }
                } else {
                    r2 = 0;
                }
                r8 = (r0 + numDefine196) | 0;
                if (r3 < 1) {
                    r9 = r8 >> numDefine2;
                    r10 = heapClassInst.heap32[r9];
                } else {
                    r9 = 0;
                    repeat12:
                    while (true) {
                        r10 = r8 >> numDefine2;
                        r10 = heapClassInst.heap32[r10];
                        r11 = r9 << numDefine2;
                        r12 = (r10 + r11) | 0;
                        r12 = r12 >> numDefine2;
                        r11 = (r2 + r11) | 0;
                        r12 = heapClassInst.heap32[r12];
                        r9 = (r9 + 1) | 0;
                        r11 = r11 >> numDefine2;
                        heapClassInst.heap32[r11] = r12;
                        if (!(r3 != r9)) {
                            break repeat12;
                        }
                    }
                    r8 = (r0 + numDefine196) | 0;
                }
                if (r10 != 0) {
                    r9 = heapClassInst.heapU8[r0 + numDefine200];
                    if (r9 != 0) {
                        r3 = gNumAlignedFree;
                        r3 = r3 >> numDefine2;
                        r9 = heapClassInst.heap32[r3];
                        r9 = (r9 + 1) | 0;
                        r10 = r10 >> numDefine2;
                        heapClassInst.heap32[r3] = r9;
                        r3 = heapClassInst.heap32[r10 + -1];
                        heapClassInst.heap32[g0] = r3;
                        free(i7);
                        r3 = heapClassInst.heap32[r1 + numDefine47];
                    }
                    r9 = r8 >> numDefine2;
                    heapClassInst.heap32[r9] = 0;
                }
                r8 = r8 >> numDefine2;
                heapClassInst.heap8[r0 + numDefine200] = (byte) r6;
                heapClassInst.heap32[r8] = r2;
                heapClassInst.heap32[r1 + numDefine48] = r7;
            }
        }
        r0 = r3 << numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine49];
        r0 = (r2 + r0) | 0;
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r0] = r4;
        r0 = heapClassInst.heap32[r1 + numDefine47];
        r0 = (r0 + 1) | 0;
        heapClassInst.heap32[r1 + numDefine47] = r0;
        if (!(r5 == 0)) {
            r0 = r4 >> numDefine2;
            r1 = heapClassInst.heap32[r0 + numDefine5];
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = r4;
            zn11btRigidBody16addConstraintRefEP17btTypedConstraint(i7);
            r0 = heapClassInst.heap32[r0 + numDefine6];
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r4;
            zn11btRigidBody16addConstraintRefEP17btTypedConstraint(i7);
        }
        
    }

    static void zn23btDiscreteDynamicsWorld21updateActivationStateEf(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr1097;
        r1 = heapClassInst.heap32[fp];
        heapClassInst.heap32[g0] = r0;
        r0 = r1 >> numDefine2;
        zn15CProfileManager13StartProfileEPKc(i7);
        r1 = heapClassInst.heap32[r0 + numDefine52];
        if (!(r1 < 1)) {
            f0 = heapClassInst.heapFloat[fp + 1];
            r1 = gDisableDeactivation;
            r1 = heapClassInst.heapU8[r1];
            r2 = 0;
            repeat3:
            while (true) {
                r3 = heapClassInst.heap32[r0 + numDefine54];
                r4 = r2 << numDefine2;
                r3 = (r3 + r4) | 0;
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3];
                repeat5:
                do {
                    if (!(r3 == 0)) {
                        r4 = r3 >> numDefine2;
                        r5 = heapClassInst.heap32[r4 + numDefine54];
                        if (!(r5 == numDefine4)) {
                            repeat8:
                            do {
                                if (r5 != numDefine2) {
                                    f1 = heapClassInst.heapFloat[r4 + numDefine76];
                                    f2 = heapClassInst.heapFloat[r4 + numDefine77];
                                    f3 = heapClassInst.heapFloat[r4 + numDefine78];
                                    f1 = f1 * f1;
                                    f2 = f2 * f2;
                                    f4 = heapClassInst.heapFloat[r4 + numDefine116];
                                    f1 = f1 + f2;
                                    f2 = f3 * f3;
                                    f1 = f1 + f2;
                                    f2 = f4 * f4;
                                    if (f1 >= f2) {
                                        label = numDefine8;
                                    } else {
                                        f1 = heapClassInst.heapFloat[r4 + numDefine80];
                                        f2 = heapClassInst.heapFloat[r4 + numDefine81];
                                        f3 = heapClassInst.heapFloat[r4 + numDefine82];
                                        f1 = f1 * f1;
                                        f2 = f2 * f2;
                                        f4 = heapClassInst.heapFloat[r4 + numDefine117];
                                        f1 = f1 + f2;
                                        f2 = f3 * f3;
                                        f1 = f1 + f2;
                                        f2 = f4 * f4;
                                        if (f1 >= f2) {
                                            label = numDefine8;
                                        } else {
                                            f1 = heapClassInst.heapFloat[r4 + numDefine55];
                                            f1 = f1 + f0;
                                            heapClassInst.heapFloat[r4 + numDefine55] = f1;
                                            label = numDefine10;
                                        }
                                    }
                                    if (label == numDefine8) {
                                        r6 = (r5 + numDefineNeg4) | 0;
                                        heapClassInst.heap32[r4 + numDefine55] = 0;
                                        if (!(uint(r6) < uint(numDefine2))) {
                                            r5 = 0;
                                            heapClassInst.heap32[r4 + numDefine54] = 0;
                                            break repeat8;
                                        }
                                    }
                                    if (r5 == numDefine4) {
                                        break repeat5;
                                    }
                                }
                            } while (false);
                            r6 = r1 & numDefine255;
                            repeat18:
                            do {
                                if (!(r6 != 0)) {
                                    r6 = (r5 + numDefineNeg2) | 0;
                                    if (!(uint(r6) < uint(numDefine2))) {
                                        f1 = heapClassInst.heapFloat[r4 + numDefine55];
                                        f2 = numDefine2;
                                        if (f1 <= f2) {
                                            break repeat18;
                                        }
                                    }
                                    r3 = heapClassInst.heapU8[r3 + numDefine204];
                                    r3 = r3 & numDefine3;
                                    if (r3 == 0) {
                                        if (r5 == numDefine2) {
                                            heapClassInst.heap32[r4 + numDefine76] = 0;
                                            heapClassInst.heap32[r4 + numDefine77] = 0;
                                            heapClassInst.heap32[r4 + numDefine78] = 0;
                                            heapClassInst.heap32[r4 + numDefine79] = 0;
                                            heapClassInst.heap32[r4 + numDefine80] = 0;
                                            heapClassInst.heap32[r4 + numDefine81] = 0;
                                            heapClassInst.heap32[r4 + numDefine82] = 0;
                                            heapClassInst.heap32[r4 + numDefine83] = 0;
                                            break repeat5;
                                        } else {
                                            if (r5 != 1) {
                                                break repeat5;
                                            } else {
                                                heapClassInst.heap32[r4 + numDefine54] = numDefine3;
                                                break repeat5;
                                            }
                                        }
                                    } else {
                                        if (uint(r5) < uint(numDefine2)) {
                                            break repeat5;
                                        } else {
                                            heapClassInst.heap32[r4 + numDefine54] = numDefine2;
                                            break repeat5;
                                        }
                                    }
                                }
                            } while (false);
                            r3 = (r5 + numDefineNeg4) | 0;
                            if (!(uint(r3) < uint(numDefine2))) {
                                heapClassInst.heap32[r4 + numDefine54] = 1;
                            }
                        }
                    }
                } while (false);
                r2 = (r2 + 1) | 0;
                r3 = heapClassInst.heap32[r0 + numDefine52];
                if (r3 > r2) {
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
        }
        r0 = zn15CProfileManager11CurrentNodeE;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        r2 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + numDefine4];
        r3 = (r3 + -1) | 0;
        heapClassInst.heap32[r2 + numDefine4] = r3;
        repeat35:
        do {
            if (!(r3 != 0)) {
                r3 = heapClassInst.heap32[r2 + 1];
                if (r3 != 0) {
                    r1 = sp + numDefineNeg8;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r3 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r1 = r1 >> numDefine2;
                    r4 = heapClassInst.heap32[fp + numDefineNeg2];
                    r5 = heapClassInst.heap32[r3];
                    r4 = (r4 - r5) | 0;
                    r1 = heapClassInst.heap32[r1 + 1];
                    r3 = heapClassInst.heap32[r3 + 1];
                    r1 = (r1 - r3) | 0;
                    r3 = (int) ((r4 * numDefineN6) | 0);
                    r1 = (r1 + r3) | 0;
                    r3 = heapClassInst.heap32[r2 + numDefine3];
                    r1 = (r1 - r3) | 0;
                    f0 = uint(r1);
                    f1 = numDefine1000;
                    f2 = heapClassInst.heapFloat[r2 + numDefine2];
                    f0 = f0 / f1;
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r2 + numDefine2] = f0;
                    r1 = heapClassInst.heap32[r2 + numDefine4];
                    if (r1 != 0) {
                        break repeat35;
                    } else {
                        r1 = heapClassInst.heap32[r0];
                    }
                }
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1 + numDefine5];
                heapClassInst.heap32[r0] = r1;
            }
        } while (false);
        return;
    }

    public static void zn23btDiscreteDynamicsWorld28internalSingleStepSimulationEf(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg32;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr1198;
        r1 = heapClassInst.heap32[fp];
        heapClassInst.heap32[g0] = r0;
        r0 = r1 >> numDefine2;
        zn15CProfileManager13StartProfileEPKc(i7);
        r2 = heapClassInst.heap32[r0 + numDefine24];
        f0 = heapClassInst.heapFloat[fp + 1];
        if (!(r2 == 0)) {
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heapFloat[g0 + 1] = f0;
            functionTable.get(r2 >> numDefine2).accept(i7);
        }
        r2 = heapClassInst.heap32[r0];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine33];
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heapFloat[g0 + 1] = f0;
        functionTable.get(r2 >> numDefine2).accept(i7);
        heapClassInst.heapFloat[r0 + numDefine7] = f0;
        heapClassInst.heap32[r0 + numDefine8] = 0;
        r2 = heapClassInst.heap32[r0];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine4];
        heapClassInst.heap32[g0] = r1;
        functionTable.get(r2 >> numDefine2).accept(i7);
        heapClassInst.heap32[r0 + numDefine12] = commonVariable.rg0;
        r2 = heapClassInst.heap32[r0];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine10];
        heapClassInst.heap32[g0] = r1;
        functionTable.get(r2 >> numDefine2).accept(i7);
        r2 = heapClassInst.heap32[r0];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine35];
        heapClassInst.heap32[g0] = r1;
        functionTable.get(r2 >> numDefine2).accept(i7);
        heapClassInst.heapFloat[r0 + numDefine29] = f0;
        r2 = heapClassInst.heap32[r0];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine36];
        r3 = (r1 + numDefine104) | 0;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = r3;
        functionTable.get(r2 >> numDefine2).accept(i7);
        r2 = heapClassInst.heap32[r0];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine34];
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heapFloat[g0 + 1] = f0;
        functionTable.get(r2 >> numDefine2).accept(i7);
        r2 = twoEStr289;
        heapClassInst.heap32[g0] = r2;
        zn15CProfileManager13StartProfileEPKc(i7);
        r2 = heapClassInst.heap32[r0 + numDefine63];
        if (!(r2 < 1)) {
            r2 = 0;
            repeat6:
            while (true) {
                r3 = heapClassInst.heap32[r0 + numDefine65];
                r4 = r2 << numDefine2;
                r3 = (r3 + r4) | 0;
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3];
                r4 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r4];
                r4 = r4 >> numDefine2;
                r4 = heapClassInst.heap32[r4 + numDefine2];
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heapFloat[g0 + numDefine2] = f0;
                r2 = (r2 + 1) | 0;
                functionTable.get(r4 >> numDefine2).accept(i7);
                r3 = heapClassInst.heap32[r0 + numDefine63];
                if (r3 > r2) {
                    continue repeat6;
                } else {
                    break repeat6;
                }
            }
        }
        r2 = zn15CProfileManager11CurrentNodeE;
        r2 = r2 >> numDefine2;
        r3 = heapClassInst.heap32[r2];
        r4 = r3 >> numDefine2;
        r5 = heapClassInst.heap32[r4 + numDefine4];
        r5 = (r5 + -1) | 0;
        heapClassInst.heap32[r4 + numDefine4] = r5;
        repeat9:
        do {
            if (!(r5 != 0)) {
                r5 = heapClassInst.heap32[r4 + 1];
                if (r5 != 0) {
                    r3 = sp + numDefineNeg16;
                    heapClassInst.heap32[g0] = r3;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r5 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r5 = r5 >> numDefine2;
                    r5 = heapClassInst.heap32[r5];
                    r5 = r5 >> numDefine2;
                    r3 = r3 >> numDefine2;
                    r6 = heapClassInst.heap32[fp + numDefineNeg4];
                    r7 = heapClassInst.heap32[r5];
                    r6 = (r6 - r7) | 0;
                    r3 = heapClassInst.heap32[r3 + 1];
                    r5 = heapClassInst.heap32[r5 + 1];
                    r3 = (r3 - r5) | 0;
                    r5 = (int) ((r6 * numDefineN6) | 0);
                    r3 = (r3 + r5) | 0;
                    r5 = heapClassInst.heap32[r4 + numDefine3];
                    r3 = (r3 - r5) | 0;
                    f1 = uint(r3);
                    f2 = numDefine1000;
                    f3 = heapClassInst.heapFloat[r4 + numDefine2];
                    f1 = f1 / f2;
                    f1 = f3 + f1;
                    heapClassInst.heapFloat[r4 + numDefine2] = f1;
                    r3 = heapClassInst.heap32[r4 + numDefine4];
                    if (r3 != 0) {
                        break repeat9;
                    } else {
                        r3 = heapClassInst.heap32[r2];
                    }
                }
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3 + numDefine5];
                heapClassInst.heap32[r2] = r3;
            }
        } while (false);
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heapFloat[g0 + 1] = f0;
        zn23btDiscreteDynamicsWorld21updateActivationStateEf(i7);
        r0 = heapClassInst.heap32[r0 + numDefine23];
        if (!(r0 == 0)) {
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heapFloat[g0 + 1] = f0;
            functionTable.get(r0 >> numDefine2).accept(i7);
        }
        r0 = heapClassInst.heap32[r2];
        r1 = r0 >> numDefine2;
        r3 = heapClassInst.heap32[r1 + numDefine4];
        r3 = (r3 + -1) | 0;
        heapClassInst.heap32[r1 + numDefine4] = r3;
        repeat19:
        do {
            if (!(r3 != 0)) {
                r3 = heapClassInst.heap32[r1 + 1];
                if (r3 != 0) {
                    r0 = sp + numDefineNeg8;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r3 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r0 = r0 >> numDefine2;
                    r4 = heapClassInst.heap32[fp + numDefineNeg2];
                    r5 = heapClassInst.heap32[r3];
                    r4 = (r4 - r5) | 0;
                    r0 = heapClassInst.heap32[r0 + 1];
                    r3 = heapClassInst.heap32[r3 + 1];
                    r0 = (r0 - r3) | 0;
                    r3 = (int) ((r4 * numDefineN6) | 0);
                    r0 = (r0 + r3) | 0;
                    r3 = heapClassInst.heap32[r1 + numDefine3];
                    r0 = (r0 - r3) | 0;
                    f0 = uint(r0);
                    f1 = numDefine1000;
                    f2 = heapClassInst.heapFloat[r1 + numDefine2];
                    f0 = f0 / f1;
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r1 + numDefine2] = f0;
                    r0 = heapClassInst.heap32[r1 + numDefine4];
                    if (r0 != 0) {
                        break repeat19;
                    } else {
                        r0 = heapClassInst.heap32[r2];
                    }
                }
                r0 = r0 >> numDefine2;
                r0 = heapClassInst.heap32[r0 + numDefine5];
                heapClassInst.heap32[r2] = r0;
            }
        } while (false);
        
    }

    public static void zn23btDiscreteDynamicsWorld12addRigidBodyEP11btRigidBodyss(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine51];
        r3 = heapClassInst.heap32[fp];
        r4 = r2 & numDefine3;
        if (!(r4 != 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine496];
            r4 = r4 & 1;
            if (!(r4 != 0)) {
                f0 = heapClassInst.heapFloat[r1 + numDefine84];
                f1 = 0;
                if (!(f0 == f1)) {
                    r4 = r3 >> numDefine2;
                    f1 = 1;
                    f0 = f1 / f0;
                    f1 = heapClassInst.heapFloat[r4 + numDefine58];
                    f2 = heapClassInst.heapFloat[r4 + numDefine57];
                    f3 = heapClassInst.heapFloat[r4 + numDefine56];
                    f3 = f3 * f0;
                    f2 = f2 * f0;
                    heapClassInst.heapFloat[r1 + numDefine89] = f3;
                    f0 = f1 * f0;
                    heapClassInst.heapFloat[r1 + numDefine90] = f2;
                    heapClassInst.heapFloat[r1 + numDefine91] = f0;
                    heapClassInst.heap32[r1 + numDefine92] = 0;
                }
                r4 = r3 >> numDefine2;
                heapClassInst.heap32[r1 + numDefine93] = heapClassInst.heap32[r4 + numDefine56];
                heapClassInst.heap32[r1 + numDefine94] = heapClassInst.heap32[r4 + numDefine57];
                heapClassInst.heap32[r1 + numDefine95] = heapClassInst.heap32[r4 + numDefine58];
                heapClassInst.heap32[r1 + numDefine96] = heapClassInst.heap32[r4 + numDefine59];
            }
        }
        r4 = heapClassInst.heap32[r1 + numDefine48];
        if (!(r4 == 0)) {
            r4 = heapClassInst.heap32[fp + numDefine2];
            r5 = heapClassInst.heap32[fp + numDefine3];
            r2 = r2 & 1;
            repeat10:
            do {
                if (r2 != 0) {
                    r2 = heapClassInst.heap32[r1 + numDefine54];
                    r2 = (r2 + numDefineNeg4) | 0;
                    if (uint(r2) < uint(numDefine2)) {
                        break repeat10;
                    } else {
                        heapClassInst.heap32[r1 + numDefine54] = numDefine2;
                    }
                } else {
                    r1 = r3 >> numDefine2;
                    r2 = heapClassInst.heap32[r1 + numDefine53];
                    r6 = heapClassInst.heap32[r1 + numDefine52];
                    if (r2 == r6) {
                        r7 = 1;
                        r8 = r6 << 1;
                        r8 = r6 == 0 ? r7 : r8;
                        if (!(r2 >= r8)) {
                            if (r8 != 0) {
                                r2 = gNumAlignedAllocs;
                                r2 = r2 >> numDefine2;
                                r9 = heapClassInst.heap32[r2];
                                r10 = r8 << numDefine2;
                                r9 = (r9 + 1) | 0;
                                r10 = r10 | numDefine3;
                                heapClassInst.heap32[r2] = r9;
                                r2 = (r10 + numDefine16) | 0;
                                heapClassInst.heap32[g0] = r2;
                                mallocNew(i7);
                                r2 = commonVariable.rg0;
                                if (r2 != 0) {
                                    r9 = 0;
                                    r10 = (r2 + numDefine4) | 0;
                                    r9 = (r9 - r10) | 0;
                                    r9 = r9 & numDefine15;
                                    r9 = (r2 + r9) | 0;
                                    r10 = (r9 + numDefine4) | 0;
                                    r9 = r9 >> numDefine2;
                                    heapClassInst.heap32[r9] = r2;
                                    r2 = r10;
                                }
                            } else {
                                r2 = 0;
                            }
                            r9 = (r3 + numDefine216) | 0;
                            if (r6 < 1) {
                                r10 = r9 >> numDefine2;
                                r11 = heapClassInst.heap32[r10];
                            } else {
                                r10 = 0;
                                repeat25:
                                while (true) {
                                    r11 = r9 >> numDefine2;
                                    r11 = heapClassInst.heap32[r11];
                                    r12 = r10 << numDefine2;
                                    r13 = (r11 + r12) | 0;
                                    r13 = r13 >> numDefine2;
                                    r12 = (r2 + r12) | 0;
                                    r13 = heapClassInst.heap32[r13];
                                    r10 = (r10 + 1) | 0;
                                    r12 = r12 >> numDefine2;
                                    heapClassInst.heap32[r12] = r13;
                                    if (!(r6 != r10)) {
                                        break repeat25;
                                    }
                                }
                                r9 = (r3 + numDefine216) | 0;
                            }
                            if (r11 != 0) {
                                r10 = heapClassInst.heapU8[r3 + numDefine220];
                                if (r10 != 0) {
                                    r6 = gNumAlignedFree;
                                    r6 = r6 >> numDefine2;
                                    r10 = heapClassInst.heap32[r6];
                                    r10 = (r10 + 1) | 0;
                                    r11 = r11 >> numDefine2;
                                    heapClassInst.heap32[r6] = r10;
                                    r6 = heapClassInst.heap32[r11 + -1];
                                    heapClassInst.heap32[g0] = r6;
                                    free(i7);
                                    r6 = heapClassInst.heap32[r1 + numDefine52];
                                }
                                r10 = r9 >> numDefine2;
                                heapClassInst.heap32[r10] = 0;
                            }
                            r9 = r9 >> numDefine2;
                            heapClassInst.heap8[r3 + numDefine220] = (byte) r7;
                            heapClassInst.heap32[r9] = r2;
                            heapClassInst.heap32[r1 + numDefine53] = r8;
                        }
                    }
                    r2 = r6 << numDefine2;
                    r6 = heapClassInst.heap32[r1 + numDefine54];
                    r2 = (r6 + r2) | 0;
                    r2 = r2 >> numDefine2;
                    heapClassInst.heap32[r2] = r0;
                    r2 = heapClassInst.heap32[r1 + numDefine52];
                    r2 = (r2 + 1) | 0;
                    heapClassInst.heap32[r1 + numDefine52] = r2;
                }
            } while (false);
            r1 = r3 >> numDefine2;
            r1 = heapClassInst.heap32[r1];
            r1 = r1 >> numDefine2;
            r1 = heapClassInst.heap32[r1 + numDefine8];
            heapClassInst.heap32[g0] = r3;
            heapClassInst.heap32[g0 + 1] = r0;
            heapClassInst.heap32[g0 + numDefine2] = r4;
            heapClassInst.heap32[g0 + numDefine3] = r5;
            functionTable.get(r1 >> numDefine2).accept(i7);
        }
        
    }

    public static void zn23btDiscreteDynamicsWorld12addRigidBodyEP11btRigidBody(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine51];
        r3 = heapClassInst.heap32[fp];
        r4 = r2 & numDefine3;
        if (!(r4 != 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine496];
            r4 = r4 & 1;
            if (!(r4 != 0)) {
                f0 = heapClassInst.heapFloat[r1 + numDefine84];
                f1 = 0;
                if (!(f0 == f1)) {
                    r4 = r3 >> numDefine2;
                    f1 = 1;
                    f0 = f1 / f0;
                    f1 = heapClassInst.heapFloat[r4 + numDefine58];
                    f2 = heapClassInst.heapFloat[r4 + numDefine57];
                    f3 = heapClassInst.heapFloat[r4 + numDefine56];
                    f3 = f3 * f0;
                    f2 = f2 * f0;
                    heapClassInst.heapFloat[r1 + numDefine89] = f3;
                    f0 = f1 * f0;
                    heapClassInst.heapFloat[r1 + numDefine90] = f2;
                    heapClassInst.heapFloat[r1 + numDefine91] = f0;
                    heapClassInst.heap32[r1 + numDefine92] = 0;
                }
                r4 = r3 >> numDefine2;
                heapClassInst.heap32[r1 + numDefine93] = heapClassInst.heap32[r4 + numDefine56];
                heapClassInst.heap32[r1 + numDefine94] = heapClassInst.heap32[r4 + numDefine57];
                heapClassInst.heap32[r1 + numDefine95] = heapClassInst.heap32[r4 + numDefine58];
                heapClassInst.heap32[r1 + numDefine96] = heapClassInst.heap32[r4 + numDefine59];
            }
        }
        r4 = heapClassInst.heap32[r1 + numDefine48];
        if (!(r4 == 0)) {
            r4 = r2 & 1;
            repeat10:
            do {
                if (r4 != 0) {
                    r4 = heapClassInst.heap32[r1 + numDefine54];
                    r4 = (r4 + numDefineNeg4) | 0;
                    if (uint(r4) > uint(1)) {
                        heapClassInst.heap32[r1 + numDefine54] = numDefine2;
                    } else {
                        break repeat10;
                    }
                } else {
                    r2 = r3 >> numDefine2;
                    r4 = heapClassInst.heap32[r2 + numDefine53];
                    r5 = heapClassInst.heap32[r2 + numDefine52];
                    if (r4 == r5) {
                        r6 = 1;
                        r7 = r5 << 1;
                        r7 = r5 == 0 ? r6 : r7;
                        if (!(r4 >= r7)) {
                            if (r7 != 0) {
                                r4 = gNumAlignedAllocs;
                                r4 = r4 >> numDefine2;
                                r8 = heapClassInst.heap32[r4];
                                r9 = r7 << numDefine2;
                                r8 = (r8 + 1) | 0;
                                r9 = r9 | numDefine3;
                                heapClassInst.heap32[r4] = r8;
                                r4 = (r9 + numDefine16) | 0;
                                heapClassInst.heap32[g0] = r4;
                                mallocNew(i7);
                                r4 = commonVariable.rg0;
                                if (r4 != 0) {
                                    r8 = 0;
                                    r9 = (r4 + numDefine4) | 0;
                                    r8 = (r8 - r9) | 0;
                                    r8 = r8 & numDefine15;
                                    r8 = (r4 + r8) | 0;
                                    r9 = (r8 + numDefine4) | 0;
                                    r8 = r8 >> numDefine2;
                                    heapClassInst.heap32[r8] = r4;
                                    r4 = r9;
                                }
                            } else {
                                r4 = 0;
                            }
                            r8 = (r3 + numDefine216) | 0;
                            if (r5 < 1) {
                                r9 = r8 >> numDefine2;
                                r10 = heapClassInst.heap32[r9];
                            } else {
                                r9 = 0;
                                repeat25:
                                while (true) {
                                    r10 = r8 >> numDefine2;
                                    r10 = heapClassInst.heap32[r10];
                                    r11 = r9 << numDefine2;
                                    r12 = (r10 + r11) | 0;
                                    r12 = r12 >> numDefine2;
                                    r11 = (r4 + r11) | 0;
                                    r12 = heapClassInst.heap32[r12];
                                    r9 = (r9 + 1) | 0;
                                    r11 = r11 >> numDefine2;
                                    heapClassInst.heap32[r11] = r12;
                                    if (!(r5 != r9)) {
                                        break repeat25;
                                    }
                                }
                                r8 = (r3 + numDefine216) | 0;
                            }
                            if (r10 != 0) {
                                r9 = heapClassInst.heapU8[r3 + numDefine220];
                                if (r9 != 0) {
                                    r5 = gNumAlignedFree;
                                    r5 = r5 >> numDefine2;
                                    r9 = heapClassInst.heap32[r5];
                                    r9 = (r9 + 1) | 0;
                                    r10 = r10 >> numDefine2;
                                    heapClassInst.heap32[r5] = r9;
                                    r5 = heapClassInst.heap32[r10 + -1];
                                    heapClassInst.heap32[g0] = r5;
                                    free(i7);
                                    r5 = heapClassInst.heap32[r2 + numDefine52];
                                }
                                r9 = r8 >> numDefine2;
                                heapClassInst.heap32[r9] = 0;
                            }
                            r8 = r8 >> numDefine2;
                            heapClassInst.heap8[r3 + numDefine220] = (byte) r6;
                            heapClassInst.heap32[r8] = r4;
                            heapClassInst.heap32[r2 + numDefine53] = r7;
                        }
                    }
                    r4 = r5 << numDefine2;
                    r5 = heapClassInst.heap32[r2 + numDefine54];
                    r4 = (r5 + r4) | 0;
                    r4 = r4 >> numDefine2;
                    heapClassInst.heap32[r4] = r0;
                    r4 = heapClassInst.heap32[r2 + numDefine52];
                    r4 = (r4 + 1) | 0;
                    heapClassInst.heap32[r2 + numDefine52] = r4;
                    r2 = heapClassInst.heap32[r1 + numDefine51];
                }
            } while (false);
            r1 = r3 >> numDefine2;
            r1 = heapClassInst.heap32[r1];
            r1 = r1 >> numDefine2;
            r1 = heapClassInst.heap32[r1 + numDefine8];
            r4 = numDefine2;
            r5 = 1;
            r2 = r2 & numDefine3;
            r6 = numDefineNeg3;
            r7 = -1;
            r4 = r2 != 0 ? r4 : r5;
            r2 = r2 != 0 ? r6 : r7;
            heapClassInst.heap32[g0] = r3;
            heapClassInst.heap32[g0 + 1] = r0;
            heapClassInst.heap32[g0 + numDefine2] = r4;
            heapClassInst.heap32[g0 + numDefine3] = r2;
            functionTable.get(r1 >> numDefine2).accept(i7);
        }
        
    }

    public static void zn23btDiscreteDynamicsWorld10setGravityERK9btVector3(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r0 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r0 + numDefine56] = heapClassInst.heap32[r1];
        heapClassInst.heap32[r0 + numDefine57] = heapClassInst.heap32[r1 + 1];
        heapClassInst.heap32[r0 + numDefine58] = heapClassInst.heap32[r1 + numDefine2];
        heapClassInst.heap32[r0 + numDefine59] = heapClassInst.heap32[r1 + numDefine3];
        r2 = heapClassInst.heap32[r0 + numDefine52];
        if (!(r2 < 1)) {
            r2 = 0;
            repeat3:
            while (true) {
                r3 = heapClassInst.heap32[r0 + numDefine54];
                r4 = r2 << numDefine2;
                r3 = (r3 + r4) | 0;
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3];
                r4 = r3 >> numDefine2;
                r5 = heapClassInst.heap32[r4 + numDefine54];
                if (!(r5 == numDefine2)) {
                    if (!(r5 == numDefine5)) {
                        r3 = heapClassInst.heapU8[r3 + numDefine496];
                        r3 = r3 & 1;
                        if (!(r3 != 0)) {
                            f0 = heapClassInst.heapFloat[r4 + numDefine84];
                            f1 = 0;
                            if (!(f0 == f1)) {
                                f1 = 1;
                                f0 = f1 / f0;
                                f1 = heapClassInst.heapFloat[r1 + numDefine2];
                                f2 = heapClassInst.heapFloat[r1 + 1];
                                f3 = heapClassInst.heapFloat[r1];
                                f3 = f3 * f0;
                                f2 = f2 * f0;
                                heapClassInst.heapFloat[r4 + numDefine89] = f3;
                                f0 = f1 * f0;
                                heapClassInst.heapFloat[r4 + numDefine90] = f2;
                                heapClassInst.heapFloat[r4 + numDefine91] = f0;
                                heapClassInst.heap32[r4 + numDefine92] = 0;
                            }
                            heapClassInst.heap32[r4 + numDefine93] = heapClassInst.heap32[r1];
                            heapClassInst.heap32[r4 + numDefine94] = heapClassInst.heap32[r1 + 1];
                            heapClassInst.heap32[r4 + numDefine95] = heapClassInst.heap32[r1 + numDefine2];
                            heapClassInst.heap32[r4 + numDefine96] = heapClassInst.heap32[r1 + numDefine3];
                        }
                    }
                }
                r2 = (r2 + 1) | 0;
                r3 = heapClassInst.heap32[r0 + numDefine52];
                if (r3 > r2) {
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
        }
        
    }

    public static void zn23btDiscreteDynamicsWorld15removeRigidBodyEP11btRigidBody(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[fp + 1];
        r3 = heapClassInst.heap32[r1 + numDefine52];
        r4 = 0;
        repeat1:
        while (true) {
            if (r3 > r4) {
                r5 = heapClassInst.heap32[r1 + numDefine54];
                r6 = r4 << numDefine2;
                r5 = (r5 + r6) | 0;
                r5 = r5 >> numDefine2;
                r5 = heapClassInst.heap32[r5];
                if (r5 != r2) {
                    r4 = (r4 + 1) | 0;
                    continue repeat1;
                } else {
                    label = numDefine5;
                    break repeat1;
                }
            } else {
                label = numDefine4;
                break repeat1;
            }
        }
        if (label == numDefine4) {
            r4 = r3;
        }
        if (!(r3 <= r4)) {
            r3 = (r3 + -1) | 0;
            r4 = r4 << numDefine2;
            r5 = heapClassInst.heap32[r1 + numDefine54];
            r3 = r3 << numDefine2;
            r4 = (r5 + r4) | 0;
            r5 = (r5 + r3) | 0;
            r4 = r4 >> numDefine2;
            r5 = r5 >> numDefine2;
            r6 = heapClassInst.heap32[r4];
            r5 = heapClassInst.heap32[r5];
            heapClassInst.heap32[r4] = r5;
            r4 = heapClassInst.heap32[r1 + numDefine54];
            r3 = (r4 + r3) | 0;
            r3 = r3 >> numDefine2;
            heapClassInst.heap32[r3] = r6;
            r3 = heapClassInst.heap32[r1 + numDefine52];
            r3 = (r3 + -1) | 0;
            heapClassInst.heap32[r1 + numDefine52] = r3;
        }
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r2;
        zn16btCollisionWorld21removeCollisionObjectEP17btCollisionObject(i7);
        
    }

    public static void zn23btDiscreteDynamicsWorld21removeCollisionObjectEP17btCollisionObject(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp];
        r2 = heapClassInst.heapU8[r0 + numDefine232];
        r2 = r2 & numDefine2;
        if (!(r2 == 0)) {
            if (!(r0 == 0)) {
                r2 = r1 >> numDefine2;
                r2 = heapClassInst.heap32[r2];
                r2 = r2 >> numDefine2;
                r2 = heapClassInst.heap32[r2 + numDefine21];
                heapClassInst.heap32[g0] = r1;
                heapClassInst.heap32[g0 + 1] = r0;
                functionTable.get(r2 >> numDefine2).accept(i7);
                
            }
        }
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = r0;
        zn16btCollisionWorld21removeCollisionObjectEP17btCollisionObject(i7);
        
    }

    public static void zn23btDiscreteDynamicsWorld18addCollisionObjectEP17btCollisionObjectss(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heap32[fp + numDefine2];
        r3 = heapClassInst.heap32[fp + numDefine3];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = r2;
        heapClassInst.heap32[g0 + numDefine3] = r3;
        zn16btCollisionWorld18addCollisionObjectEP17btCollisionObjectss(i7);
        
    }

    public static void zn23btDiscreteDynamicsWorld14stepSimulationEfif(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        zn15CProfileManager5ResetEv(i7);
        r0 = twoEStr1299;
        r1 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[g0] = r0;
        r0 = heapClassInst.heap32[fp];
        f0 = heapClassInst.heapFloat[fp + 1];
        zn15CProfileManager13StartProfileEPKc(i7);
        if (r1 == 0) {
            r1 = r0 >> numDefine2;
            f1 = 0;
            heapClassInst.heapFloat[r1 + numDefine60] = f0;
            if (f0 < f1) {
                f1 = -f0;
            } else {
                f1 = f0;
            }
            f2 = (float) numDefineFloat1257;
            if (f1 >= f2) {
                r1 = 1;
                f1 = f0;
                r3 = r1;
            } else {
                r1 = 0;
                f1 = f0;
                r3 = r1;
            }
        } else {
            f1 = heapClassInst.heapFloat[fp + numDefine3];
            r2 = r0 >> numDefine2;
            f2 = heapClassInst.heapFloat[r2 + numDefine60];
            f0 = f2 + f0;
            heapClassInst.heapFloat[r2 + numDefine60] = f0;
            if (f0 >= f1) {
                f2 = f0 / f1;
                r3 = (int) f2 | 0;
                f2 = r3;
                f2 = f2 * f1;
                f0 = f0 - f2;
                heapClassInst.heapFloat[r2 + numDefine60] = f0;
            } else {
                r3 = 0;
            }
        }
        r2 = r0 >> numDefine2;
        r4 = heapClassInst.heap32[r2];
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + numDefine4];
        heapClassInst.heap32[g0] = r0;
        functionTable.get(r4 >> numDefine2).accept(i7);
        r4 = commonVariable.rg0;
        if (!(r4 == 0)) {
            r4 = heapClassInst.heap32[r2];
            r4 = r4 >> numDefine2;
            r4 = heapClassInst.heap32[r4 + numDefine4];
            heapClassInst.heap32[g0] = r0;
            functionTable.get(r4 >> numDefine2).accept(i7);
            r5 = commonVariable.rg0 >> numDefine2;
            r5 = heapClassInst.heap32[r5];
            r5 = r5 >> numDefine2;
            r5 = heapClassInst.heap32[r5 + numDefine12];
            heapClassInst.heap32[g0] = commonVariable.rg0;
            functionTable.get(r5 >> numDefine2).accept(i7);
            r4 = commonVariable.rg0 >>> numDefine4;
            r5 = gDisableDeactivation;
            r4 = r4 & 1;
            heapClassInst.heap8[r5] = (byte) r4;
        }
        if (r3 == 0) {
            r1 = heapClassInst.heap32[r2];
            r1 = r1 >> numDefine2;
            r1 = heapClassInst.heap32[r1 + numDefine19];
            heapClassInst.heap32[g0] = r0;
            functionTable.get(r1 >> numDefine2).accept(i7);
        } else {
            r4 = heapClassInst.heap32[r2];
            r4 = r4 >> numDefine2;
            r5 = r3 > r1 ? r1 : r3;
            r4 = heapClassInst.heap32[r4 + numDefine38];
            f0 = r5;
            f0 = f0 * f1;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heapFloat[g0 + 1] = f0;
            functionTable.get(r4 >> numDefine2).accept(i7);
            r4 = heapClassInst.heap32[r2];
            r4 = r4 >> numDefine2;
            r4 = heapClassInst.heap32[r4 + numDefine40];
            heapClassInst.heap32[g0] = r0;
            functionTable.get(r4 >> numDefine2).accept(i7);
            if (!(r5 < 1)) {
                r4 = r3 ^ -1;
                r1 = r1 ^ -1;
                r1 = r4 > r1 ? r4 : r1;
                r1 = r1 ^ -1;
                repeat22:
                while (true) {
                    r4 = heapClassInst.heap32[r2];
                    r4 = r4 >> numDefine2;
                    r4 = heapClassInst.heap32[r4 + numDefine37];
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heapFloat[g0 + 1] = f1;
                    functionTable.get(r4 >> numDefine2).accept(i7);
                    r4 = heapClassInst.heap32[r2];
                    r4 = r4 >> numDefine2;
                    r4 = heapClassInst.heap32[r4 + numDefine19];
                    r1 = (r1 + -1) | 0;
                    heapClassInst.heap32[g0] = r0;
                    functionTable.get(r4 >> numDefine2).accept(i7);
                    if (r1 == 0) {
                        break repeat22;
                    } else {
                        continue repeat22;
                    }
                }
            }
        }
        r1 = heapClassInst.heap32[r2];
        r1 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine28];
        heapClassInst.heap32[g0] = r0;
        r0 = zn15CProfileManager12FrameCounterE;
        functionTable.get(r1 >> numDefine2).accept(i7);
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        r2 = zn15CProfileManager11CurrentNodeE;
        r1 = (r1 + 1) | 0;
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r0] = r1;
        r0 = heapClassInst.heap32[r2];
        r1 = r0 >> numDefine2;
        r4 = heapClassInst.heap32[r1 + numDefine4];
        r4 = (r4 + -1) | 0;
        heapClassInst.heap32[r1 + numDefine4] = r4;
        repeat25:
        do {
            if (!(r4 != 0)) {
                r4 = heapClassInst.heap32[r1 + 1];
                if (r4 != 0) {
                    r0 = sp + numDefineNeg8;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r4 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r4 = r4 >> numDefine2;
                    r4 = heapClassInst.heap32[r4];
                    r4 = r4 >> numDefine2;
                    r0 = r0 >> numDefine2;
                    r5 = heapClassInst.heap32[fp + numDefineNeg2];
                    r6 = heapClassInst.heap32[r4];
                    r5 = (r5 - r6) | 0;
                    r0 = heapClassInst.heap32[r0 + 1];
                    r4 = heapClassInst.heap32[r4 + 1];
                    r0 = (r0 - r4) | 0;
                    r4 = (int) ((r5 * numDefineN6) | 0);
                    r0 = (r0 + r4) | 0;
                    r4 = heapClassInst.heap32[r1 + numDefine3];
                    r0 = (r0 - r4) | 0;
                    f0 = uint(r0);
                    f1 = numDefine1000;
                    f2 = heapClassInst.heapFloat[r1 + numDefine2];
                    f0 = f0 / f1;
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r1 + numDefine2] = f0;
                    r0 = heapClassInst.heap32[r1 + numDefine4];
                    if (r0 != 0) {
                        break repeat25;
                    } else {
                        r0 = heapClassInst.heap32[r2];
                    }
                }
                r0 = r0 >> numDefine2;
                r0 = heapClassInst.heap32[r0 + numDefine5];
                heapClassInst.heap32[r2] = r0;
            }
        } while (false);
        commonVariable.rg0 = r3;
        
    }

    static void zn23btDiscreteDynamicsWorld28synchronizeSingleMotionStateEP11btRigidBody(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg96;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        if (r0 != 0) {
            r1 = r0 >> numDefine2;
            r2 = heapClassInst.heap32[r1 + numDefine118];
            if (!(r2 == 0)) {
                r2 = heapClassInst.heapU8[r0 + numDefine204];
                r2 = r2 & numDefine3;
                if (r2 == 0) {
                    r2 = heapClassInst.heap32[fp];
                    r2 = r2 >> numDefine2;
                    f0 = heapClassInst.heapFloat[r2 + numDefine60];
                    f1 = heapClassInst.heapFloat[r1 + numDefine60];
                    f2 = heapClassInst.heapFloat[r1 + numDefine33];
                    f3 = heapClassInst.heapFloat[r1 + numDefine34];
                    f4 = heapClassInst.heapFloat[r1 + numDefine35];
                    r2 = sp + numDefineNeg64;
                    r3 = (r0 + numDefine68) | 0;
                    r0 = (r0 + numDefine148) | 0;
                    f0 = f0 * f1;
                    heapClassInst.heap32[g0] = r3;
                    heapClassInst.heapFloat[g0 + 1] = f2;
                    heapClassInst.heapFloat[g0 + numDefine2] = f3;
                    heapClassInst.heapFloat[g0 + numDefine3] = f4;
                    heapClassInst.heap32[g0 + numDefine4] = r0;
                    heapClassInst.heapFloat[g0 + numDefine5] = f0;
                    heapClassInst.heap32[g0 + numDefine6] = r2;
                    zn15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5FRS0(i7);
                    r0 = heapClassInst.heap32[r1 + numDefine118];
                    r1 = r0 >> numDefine2;
                    r1 = heapClassInst.heap32[r1];
                    r1 = r1 >> numDefine2;
                    r1 = heapClassInst.heap32[r1 + numDefine3];
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r2;
                    functionTable.get(r1 >> numDefine2).accept(i7);
                    return;
                }
            }
            return;
        } else {
            r0 = twoEStr13100;
            r1 = twoEStr1461;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine184;
            assertNew(i7);
        }
    }

    public static void zn23btDiscreteDynamicsWorld23synchronizeMotionStatesEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr1562;
        heapClassInst.heap32[g0] = r0;
        r0 = heapClassInst.heap32[fp];
        zn15CProfileManager13StartProfileEPKc(i7);
        r1 = heapClassInst.heapU8[r0 + numDefine246];
        repeat1:
        do {
            if (r1 != 0) {
                r1 = r0 >> numDefine2;
                r2 = heapClassInst.heap32[r1 + numDefine2];
                if (!(r2 < 1)) {
                    r2 = 0;
                    repeat4:
                    while (true) {
                        r3 = heapClassInst.heap32[r1 + numDefine4];
                        r4 = r2 << numDefine2;
                        r3 = (r3 + r4) | 0;
                        r3 = r3 >> numDefine2;
                        r3 = heapClassInst.heap32[r3];
                        r4 = heapClassInst.heapU8[r3 + numDefine232];
                        r4 = r4 & numDefine2;
                        if (!(r4 == 0)) {
                            if (!(r3 == 0)) {
                                heapClassInst.heap32[g0] = r0;
                                heapClassInst.heap32[g0 + 1] = r3;
                                zn23btDiscreteDynamicsWorld28synchronizeSingleMotionStateEP11btRigidBody(i7);
                            }
                        }
                        r2 = (r2 + 1) | 0;
                        r3 = heapClassInst.heap32[r1 + numDefine2];
                        if (r3 > r2) {
                            continue repeat4;
                        } else {
                            break repeat1;
                        }
                    }
                }
            } else {
                r1 = r0 >> numDefine2;
                r2 = heapClassInst.heap32[r1 + numDefine52];
                if (r2 > 0) {
                    r2 = 0;
                    repeat12:
                    while (true) {
                        r3 = heapClassInst.heap32[r1 + numDefine54];
                        r4 = r2 << numDefine2;
                        r3 = (r3 + r4) | 0;
                        r3 = r3 >> numDefine2;
                        r3 = heapClassInst.heap32[r3];
                        r4 = r3 >> numDefine2;
                        r4 = heapClassInst.heap32[r4 + numDefine54];
                        if (!(r4 == numDefine2)) {
                            if (!(r4 == numDefine5)) {
                                heapClassInst.heap32[g0] = r0;
                                heapClassInst.heap32[g0 + 1] = r3;
                                zn23btDiscreteDynamicsWorld28synchronizeSingleMotionStateEP11btRigidBody(i7);
                            }
                        }
                        r2 = (r2 + 1) | 0;
                        r3 = heapClassInst.heap32[r1 + numDefine52];
                        if (r3 > r2) {
                            continue repeat12;
                        } else {
                            break repeat1;
                        }
                    }
                }
            }
        } while (false);
        r0 = zn15CProfileManager11CurrentNodeE;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        r2 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + numDefine4];
        r3 = (r3 + -1) | 0;
        heapClassInst.heap32[r2 + numDefine4] = r3;
        repeat19:
        do {
            if (!(r3 != 0)) {
                r3 = heapClassInst.heap32[r2 + 1];
                if (r3 != 0) {
                    r1 = sp + numDefineNeg8;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r3 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r1 = r1 >> numDefine2;
                    r4 = heapClassInst.heap32[fp + numDefineNeg2];
                    r5 = heapClassInst.heap32[r3];
                    r4 = (r4 - r5) | 0;
                    r1 = heapClassInst.heap32[r1 + 1];
                    r3 = heapClassInst.heap32[r3 + 1];
                    r1 = (r1 - r3) | 0;
                    r3 = (int) ((r4 * numDefineN6) | 0);
                    r1 = (r1 + r3) | 0;
                    r3 = heapClassInst.heap32[r2 + numDefine3];
                    r1 = (r1 - r3) | 0;
                    f0 = uint(r1);
                    f1 = numDefine1000;
                    f2 = heapClassInst.heapFloat[r2 + numDefine2];
                    f0 = f0 / f1;
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r2 + numDefine2] = f0;
                    r1 = heapClassInst.heap32[r2 + numDefine4];
                    if (r1 != 0) {
                        break repeat19;
                    } else {
                        r1 = heapClassInst.heap32[r0];
                    }
                }
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1 + numDefine5];
                heapClassInst.heap32[r0] = r1;
            }
        } while (false);
        
    }

    public static void zn23btDiscreteDynamicsWorld12applyGravityEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + numDefine52];
        if (!(r1 < 1)) {
            r1 = 0;
            repeat3:
            while (true) {
                r2 = heapClassInst.heap32[r0 + numDefine54];
                r3 = r1 << numDefine2;
                r2 = (r2 + r3) | 0;
                r2 = r2 >> numDefine2;
                r2 = heapClassInst.heap32[r2];
                r3 = r2 >> numDefine2;
                r4 = heapClassInst.heap32[r3 + numDefine54];
                if (!(r4 == numDefine2)) {
                    if (!(r4 == numDefine5)) {
                        r2 = heapClassInst.heapU8[r2 + numDefine204];
                        r2 = r2 & numDefine3;
                        if (!(r2 != 0)) {
                            f0 = heapClassInst.heapFloat[r3 + numDefine89];
                            f1 = heapClassInst.heapFloat[r3 + numDefine85];
                            f0 = f0 * f1;
                            f1 = heapClassInst.heapFloat[r3 + numDefine101];
                            f2 = heapClassInst.heapFloat[r3 + numDefine91];
                            f3 = heapClassInst.heapFloat[r3 + numDefine87];
                            f4 = heapClassInst.heapFloat[r3 + numDefine90];
                            f5 = heapClassInst.heapFloat[r3 + numDefine86];
                            f0 = f1 + f0;
                            heapClassInst.heapFloat[r3 + numDefine101] = f0;
                            f0 = f4 * f5;
                            f1 = heapClassInst.heapFloat[r3 + numDefine102];
                            f0 = f1 + f0;
                            heapClassInst.heapFloat[r3 + numDefine102] = f0;
                            f0 = f2 * f3;
                            f1 = heapClassInst.heapFloat[r3 + numDefine103];
                            f0 = f1 + f0;
                            heapClassInst.heapFloat[r3 + numDefine103] = f0;
                        }
                    }
                }
                r1 = (r1 + 1) | 0;
                r2 = heapClassInst.heap32[r0 + numDefine52];
                if (r2 > r1) {
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
        }
        
    }

    public static void zn23btDiscreteDynamicsWorld14debugDrawWorldEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        float f28 = 0.0F;
        float f29 = 0.0F;
        float f30 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg824;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr16101;
        heapClassInst.heap32[g0] = r0;
        zn15CProfileManager13StartProfileEPKc(i7);
        r0 = heapClassInst.heap32[fp];
        heapClassInst.heap32[g0] = r0;
        zn16btCollisionWorld14debugDrawWorldEv(i7);
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine4];
        heapClassInst.heap32[g0] = r0;
        functionTable.get(r2 >> numDefine2).accept(i7);
        r2 = commonVariable.rg0;
        if (!(r2 == 0)) {
            r2 = heapClassInst.heap32[r1];
            r2 = r2 >> numDefine2;
            r2 = heapClassInst.heap32[r2 + numDefine4];
            heapClassInst.heap32[g0] = r0;
            functionTable.get(r2 >> numDefine2).accept(i7);
            r3 = commonVariable.rg0 >> numDefine2;
            r3 = heapClassInst.heap32[r3];
            r3 = r3 >> numDefine2;
            r3 = heapClassInst.heap32[r3 + numDefine12];
            heapClassInst.heap32[g0] = commonVariable.rg0;
            functionTable.get(r3 >> numDefine2).accept(i7);
            r2 = commonVariable.rg0 & numDefine6144;
            if (!(r2 == 0)) {
                r2 = heapClassInst.heap32[r1];
                r2 = r2 >> numDefine2;
                r2 = heapClassInst.heap32[r2 + numDefine24];
                heapClassInst.heap32[g0] = r0;
                functionTable.get(r2 >> numDefine2).accept(i7);
                r2 = commonVariable.rg0;
                r3 = (r2 + -1) | 0;
                if (!(r3 < 0)) {
                    r3 = sp + numDefineNeg296;
                    r4 = sp + numDefineNeg392;
                    r5 = (r3 + numDefine48) | 0;
                    r6 = (r4 + numDefine48) | 0;
                    r2 = (r2 + -1) | 0;
                    repeat5:
                    while (true) {
                        r7 = r2;
                        r2 = heapClassInst.heap32[r1];
                        r2 = r2 >> numDefine2;
                        r2 = heapClassInst.heap32[r2 + numDefine25];
                        heapClassInst.heap32[g0] = r0;
                        heapClassInst.heap32[g0 + 1] = r7;
                        functionTable.get(r2 >> numDefine2).accept(i7);
                        r2 = commonVariable.rg0;
                        r8 = heapClassInst.heap32[r1];
                        r8 = r8 >> numDefine2;
                        r8 = heapClassInst.heap32[r8 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        functionTable.get(r8 >> numDefine2).accept(i7);
                        r9 = commonVariable.rg0 >> numDefine2;
                        r9 = heapClassInst.heap32[r9];
                        r9 = r9 >> numDefine2;
                        r9 = heapClassInst.heap32[r9 + numDefine12];
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        functionTable.get(r9 >> numDefine2).accept(i7);
                        r8 = commonVariable.rg0;
                        r9 = heapClassInst.heap32[r1];
                        r9 = r9 >> numDefine2;
                        r9 = heapClassInst.heap32[r9 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        functionTable.get(r9 >> numDefine2).accept(i7);
                        r10 = commonVariable.rg0 >> numDefine2;
                        r10 = heapClassInst.heap32[r10];
                        r10 = r10 >> numDefine2;
                        r10 = heapClassInst.heap32[r10 + numDefine12];
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        functionTable.get(r10 >> numDefine2).accept(i7);
                        r9 = commonVariable.rg0;
                        r10 = r2 >> numDefine2;
                        f0 = heapClassInst.heapFloat[r10 + numDefine8];
                        heapClassInst.heapFloat[fp + numDefineNeg191] = f0;
                        f1 = 0;
                        heapClassInst.heapFloat[fp + numDefineNeg192] = f1;
                        repeat7:
                        do {
                            if (!(f0 <= f1)) {
                                r8 = r8 >>> numDefine11;
                                r9 = r9 >>> numDefine12;
                                r8 = r8 & 1;
                                r9 = r9 & 1;
                                r10 = r2 >> numDefine2;
                                r11 = heapClassInst.heap32[r10 + 1];
                                if (r11 > numDefine4) {
                                    if (r11 == numDefine5) {
                                        r11 = heapClassInst.heap32[r10 + numDefine5];
                                        r11 = r11 >> numDefine2;
                                        f0 = heapClassInst.heapFloat[r11 + 1];
                                        f1 = heapClassInst.heapFloat[r10 + numDefine72];
                                        f2 = heapClassInst.heapFloat[r11 + numDefine2];
                                        f3 = heapClassInst.heapFloat[r10 + numDefine76];
                                        f4 = heapClassInst.heapFloat[r10 + numDefine73];
                                        f5 = heapClassInst.heapFloat[r10 + numDefine77];
                                        f6 = f1 * f0;
                                        f7 = f3 * f2;
                                        f8 = heapClassInst.heapFloat[r11 + numDefine3];
                                        f9 = heapClassInst.heapFloat[r10 + numDefine80];
                                        f10 = heapClassInst.heapFloat[r11 + numDefine9];
                                        f11 = heapClassInst.heapFloat[r10 + numDefine84];
                                        f12 = heapClassInst.heapFloat[r11 + numDefine5];
                                        f13 = heapClassInst.heapFloat[r10 + numDefine74];
                                        f14 = heapClassInst.heapFloat[r11 + numDefine10];
                                        f15 = heapClassInst.heapFloat[r10 + numDefine85];
                                        f16 = heapClassInst.heapFloat[r11 + numDefine6];
                                        f17 = heapClassInst.heapFloat[r10 + numDefine78];
                                        f18 = heapClassInst.heapFloat[r11 + numDefine11];
                                        f19 = heapClassInst.heapFloat[r10 + numDefine86];
                                        f20 = heapClassInst.heapFloat[r11 + numDefine7];
                                        f21 = heapClassInst.heapFloat[r10 + numDefine82];
                                        f22 = heapClassInst.heapFloat[r10 + numDefine81];
                                        f23 = f4 * f0;
                                        f24 = f5 * f2;
                                        f6 = f6 + f7;
                                        f7 = f9 * f8;
                                        f25 = heapClassInst.heapFloat[r11 + numDefine15];
                                        f26 = heapClassInst.heapFloat[r11 + numDefine14];
                                        f27 = heapClassInst.heapFloat[r11 + numDefine13];
                                        f28 = f13 * f0;
                                        f29 = f17 * f2;
                                        f23 = f23 + f24;
                                        f24 = f22 * f8;
                                        f6 = f6 + f7;
                                        r11 = r4 >> numDefine2;
                                        f7 = f28 + f29;
                                        f28 = f21 * f8;
                                        f23 = f23 + f24;
                                        heapClassInst.heapFloat[fp + numDefineNeg98] = f6;
                                        f6 = f1 * f12;
                                        f24 = f3 * f16;
                                        f7 = f7 + f28;
                                        heapClassInst.heapFloat[r11 + 1] = f23;
                                        heapClassInst.heapFloat[r11 + numDefine2] = f7;
                                        f7 = f4 * f12;
                                        f23 = f5 * f16;
                                        f6 = f6 + f24;
                                        f24 = f9 * f20;
                                        f28 = f13 * f12;
                                        f29 = f17 * f16;
                                        f7 = f7 + f23;
                                        f23 = f22 * f20;
                                        f6 = f6 + f24;
                                        heapClassInst.heap32[r11 + numDefine3] = 0;
                                        f24 = f28 + f29;
                                        f28 = f21 * f20;
                                        f7 = f7 + f23;
                                        heapClassInst.heapFloat[r11 + numDefine4] = f6;
                                        f1 = f1 * f10;
                                        f3 = f3 * f14;
                                        f6 = f24 + f28;
                                        heapClassInst.heapFloat[r11 + numDefine5] = f7;
                                        heapClassInst.heapFloat[r11 + numDefine6] = f6;
                                        f4 = f4 * f10;
                                        f5 = f5 * f14;
                                        f1 = f1 + f3;
                                        f3 = f9 * f18;
                                        f6 = f13 * f10;
                                        f7 = f17 * f14;
                                        f4 = f4 + f5;
                                        f5 = f22 * f18;
                                        f1 = f1 + f3;
                                        heapClassInst.heap32[r11 + numDefine7] = 0;
                                        f0 = f0 * f11;
                                        f2 = f2 * f15;
                                        f3 = f6 + f7;
                                        f6 = f21 * f18;
                                        f4 = f4 + f5;
                                        heapClassInst.heapFloat[r11 + numDefine8] = f1;
                                        f1 = f12 * f11;
                                        f5 = f16 * f15;
                                        f0 = f0 + f2;
                                        f2 = f8 * f19;
                                        f3 = f3 + f6;
                                        heapClassInst.heapFloat[r11 + numDefine9] = f4;
                                        f0 = f0 + f2;
                                        heapClassInst.heapFloat[r11 + numDefine10] = f3;
                                        f2 = f10 * f11;
                                        f3 = f14 * f15;
                                        f1 = f1 + f5;
                                        f4 = f20 * f19;
                                        f1 = f1 + f4;
                                        f2 = f2 + f3;
                                        f3 = f18 * f19;
                                        f0 = f0 + f27;
                                        heapClassInst.heap32[r11 + numDefine11] = 0;
                                        f2 = f2 + f3;
                                        f1 = f1 + f26;
                                        heapClassInst.heapFloat[r11 + numDefine12] = f0;
                                        f0 = f2 + f25;
                                        heapClassInst.heapFloat[r11 + numDefine13] = f1;
                                        heapClassInst.heapFloat[r11 + numDefine14] = f0;
                                        heapClassInst.heap32[r11 + numDefine15] = 0;
                                        if (!(r8 == 0)) {
                                            r12 = heapClassInst.heap32[r1];
                                            r12 = r12 >> numDefine2;
                                            r12 = heapClassInst.heap32[r12 + numDefine4];
                                            heapClassInst.heap32[g0] = r0;
                                            functionTable.get(r12 >> numDefine2).accept(i7);
                                            r13 = commonVariable.rg0 >> numDefine2;
                                            r13 = heapClassInst.heap32[r13];
                                            r13 = r13 >> numDefine2;
                                            r13 = heapClassInst.heap32[r13 + numDefine14];
                                            heapClassInst.heap32[g0] = commonVariable.rg0;
                                            heapClassInst.heap32[g0 + 1] = r4;
                                            f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                            heapClassInst.heapFloat[g0 + numDefine2] = f0;
                                            functionTable.get(r13 >> numDefine2).accept(i7);
                                        }
                                        r12 = heapClassInst.heap32[r10 + numDefine6];
                                        r12 = r12 >> numDefine2;
                                        f0 = heapClassInst.heapFloat[r12 + 1];
                                        f1 = heapClassInst.heapFloat[r10 + numDefine88];
                                        f2 = heapClassInst.heapFloat[r12 + numDefine2];
                                        f3 = heapClassInst.heapFloat[r10 + numDefine92];
                                        f4 = heapClassInst.heapFloat[r10 + numDefine89];
                                        f5 = heapClassInst.heapFloat[r10 + numDefine93];
                                        f6 = f1 * f0;
                                        f7 = f3 * f2;
                                        f8 = heapClassInst.heapFloat[r12 + numDefine3];
                                        f9 = heapClassInst.heapFloat[r10 + numDefine96];
                                        f10 = heapClassInst.heapFloat[r12 + numDefine9];
                                        f11 = heapClassInst.heapFloat[r10 + numDefine100];
                                        f12 = heapClassInst.heapFloat[r12 + numDefine5];
                                        f13 = heapClassInst.heapFloat[r10 + numDefine90];
                                        f14 = heapClassInst.heapFloat[r12 + numDefine10];
                                        f15 = heapClassInst.heapFloat[r10 + numDefine101];
                                        f16 = heapClassInst.heapFloat[r12 + numDefine6];
                                        f17 = heapClassInst.heapFloat[r10 + numDefine94];
                                        f18 = heapClassInst.heapFloat[r12 + numDefine11];
                                        f19 = heapClassInst.heapFloat[r10 + numDefine102];
                                        f20 = heapClassInst.heapFloat[r12 + numDefine7];
                                        f21 = heapClassInst.heapFloat[r10 + numDefine98];
                                        f22 = heapClassInst.heapFloat[r10 + numDefine97];
                                        f23 = f4 * f0;
                                        f24 = f5 * f2;
                                        f6 = f6 + f7;
                                        f7 = f9 * f8;
                                        f25 = heapClassInst.heapFloat[r12 + numDefine15];
                                        f26 = heapClassInst.heapFloat[r12 + numDefine14];
                                        f27 = heapClassInst.heapFloat[r12 + numDefine13];
                                        f28 = f13 * f0;
                                        f29 = f17 * f2;
                                        f23 = f23 + f24;
                                        f24 = f22 * f8;
                                        f6 = f6 + f7;
                                        f7 = f28 + f29;
                                        f28 = f21 * f8;
                                        f23 = f23 + f24;
                                        heapClassInst.heapFloat[fp + numDefineNeg98] = f6;
                                        f6 = f1 * f12;
                                        f24 = f3 * f16;
                                        f7 = f7 + f28;
                                        heapClassInst.heapFloat[r11 + 1] = f23;
                                        heapClassInst.heapFloat[r11 + numDefine2] = f7;
                                        f7 = f4 * f12;
                                        f23 = f5 * f16;
                                        f6 = f6 + f24;
                                        f24 = f9 * f20;
                                        f28 = f13 * f12;
                                        f29 = f17 * f16;
                                        f7 = f7 + f23;
                                        f23 = f22 * f20;
                                        f6 = f6 + f24;
                                        heapClassInst.heap32[r11 + numDefine3] = 0;
                                        f24 = f28 + f29;
                                        f28 = f21 * f20;
                                        f7 = f7 + f23;
                                        heapClassInst.heapFloat[r11 + numDefine4] = f6;
                                        f1 = f1 * f10;
                                        f3 = f3 * f14;
                                        f6 = f24 + f28;
                                        heapClassInst.heapFloat[r11 + numDefine5] = f7;
                                        heapClassInst.heapFloat[r11 + numDefine6] = f6;
                                        f4 = f4 * f10;
                                        f5 = f5 * f14;
                                        f1 = f1 + f3;
                                        f3 = f9 * f18;
                                        f6 = f13 * f10;
                                        f7 = f17 * f14;
                                        f4 = f4 + f5;
                                        f5 = f22 * f18;
                                        f1 = f1 + f3;
                                        heapClassInst.heap32[r11 + numDefine7] = 0;
                                        f0 = f0 * f11;
                                        f2 = f2 * f15;
                                        f3 = f6 + f7;
                                        f6 = f21 * f18;
                                        f4 = f4 + f5;
                                        heapClassInst.heapFloat[r11 + numDefine8] = f1;
                                        f1 = f12 * f11;
                                        f5 = f16 * f15;
                                        f0 = f0 + f2;
                                        f2 = f8 * f19;
                                        f3 = f3 + f6;
                                        heapClassInst.heapFloat[r11 + numDefine9] = f4;
                                        f0 = f0 + f2;
                                        heapClassInst.heapFloat[r11 + numDefine10] = f3;
                                        f2 = f10 * f11;
                                        f3 = f14 * f15;
                                        f1 = f1 + f5;
                                        f4 = f20 * f19;
                                        f1 = f1 + f4;
                                        f2 = f2 + f3;
                                        f3 = f18 * f19;
                                        f0 = f0 + f27;
                                        heapClassInst.heap32[r11 + numDefine11] = 0;
                                        f2 = f2 + f3;
                                        f1 = f1 + f26;
                                        heapClassInst.heapFloat[r11 + numDefine12] = f0;
                                        f0 = f2 + f25;
                                        heapClassInst.heapFloat[r11 + numDefine13] = f1;
                                        heapClassInst.heapFloat[r11 + numDefine14] = f0;
                                        heapClassInst.heap32[r11 + numDefine15] = 0;
                                        if (!(r8 == 0)) {
                                            r8 = heapClassInst.heap32[r1];
                                            r8 = r8 >> numDefine2;
                                            r8 = heapClassInst.heap32[r8 + numDefine4];
                                            heapClassInst.heap32[g0] = r0;
                                            functionTable.get(r8 >> numDefine2).accept(i7);
                                            r12 = commonVariable.rg0 >> numDefine2;
                                            r12 = heapClassInst.heap32[r12];
                                            r12 = r12 >> numDefine2;
                                            r12 = heapClassInst.heap32[r12 + numDefine14];
                                            heapClassInst.heap32[g0] = commonVariable.rg0;
                                            heapClassInst.heap32[g0 + 1] = r4;
                                            f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                            heapClassInst.heapFloat[g0 + numDefine2] = f0;
                                            functionTable.get(r12 >> numDefine2).accept(i7);
                                        }
                                        if (r9 == 0) {
                                            break repeat7;
                                        } else {
                                            r8 = sp + numDefineNeg408;
                                            heapClassInst.heap32[g0] = r8;
                                            heapClassInst.heap32[g0 + 1] = r2;
                                            heapClassInst.heap32[g0 + numDefine2] = (int) numDefine06843;
                                            f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                            heapClassInst.heapFloat[g0 + numDefine3] = f0;
                                            znk21btConeTwistConstraint16GetPointForAngleEff(i7);
                                            r9 = r8 >> numDefine2;
                                            f0 = heapClassInst.heapFloat[fp + numDefineNeg102];
                                            f1 = heapClassInst.heapFloat[fp + numDefineNeg98];
                                            f2 = heapClassInst.heapFloat[r9 + 1];
                                            f3 = heapClassInst.heapFloat[r11 + 1];
                                            f4 = heapClassInst.heapFloat[r11 + numDefine4];
                                            f5 = heapClassInst.heapFloat[r11 + numDefine5];
                                            f1 = f1 * f0;
                                            f3 = f3 * f2;
                                            f6 = heapClassInst.heapFloat[r9 + numDefine2];
                                            f7 = heapClassInst.heapFloat[r11 + numDefine2];
                                            f8 = heapClassInst.heapFloat[r11 + numDefine8];
                                            f9 = heapClassInst.heapFloat[r11 + numDefine9];
                                            f10 = heapClassInst.heapFloat[r11 + numDefine6];
                                            f4 = f4 * f0;
                                            f5 = f5 * f2;
                                            f1 = f1 + f3;
                                            f3 = f7 * f6;
                                            f7 = heapClassInst.heapFloat[r11 + numDefine10];
                                            f0 = f8 * f0;
                                            f2 = f9 * f2;
                                            f4 = f4 + f5;
                                            f5 = f10 * f6;
                                            f1 = f1 + f3;
                                            f3 = heapClassInst.heapFloat[r11 + numDefine12];
                                            f8 = heapClassInst.heapFloat[r11 + numDefine14];
                                            f9 = heapClassInst.heapFloat[r11 + numDefine13];
                                            f4 = f4 + f5;
                                            f0 = f0 + f2;
                                            f2 = f7 * f6;
                                            f1 = f1 + f3;
                                            f0 = f0 + f2;
                                            f2 = f4 + f9;
                                            heapClassInst.heapFloat[fp + numDefineNeg102] = f1;
                                            f0 = f0 + f8;
                                            heapClassInst.heapFloat[r9 + 1] = f2;
                                            r12 = 0;
                                            heapClassInst.heapFloat[r9 + numDefine2] = f0;
                                            heapClassInst.heap32[r9 + numDefine3] = 0;
                                            repeat20:
                                            while (true) {
                                                f0 = r12;
                                                f1 = (float) numDefineFloat283;
                                                f0 = f0 * f1;
                                                f1 = numDefine32;
                                                r13 = sp + numDefineNeg472;
                                                f0 = f0 / f1;
                                                heapClassInst.heap32[g0] = r13;
                                                heapClassInst.heap32[g0 + 1] = r2;
                                                heapClassInst.heapFloat[g0 + numDefine2] = f0;
                                                f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                                heapClassInst.heapFloat[g0 + numDefine3] = f0;
                                                znk21btConeTwistConstraint16GetPointForAngleEff(i7);
                                                r14 = r13 >> numDefine2;
                                                f0 = heapClassInst.heapFloat[fp + numDefineNeg118];
                                                f1 = heapClassInst.heapFloat[fp + numDefineNeg98];
                                                f2 = heapClassInst.heapFloat[r14 + 1];
                                                f3 = heapClassInst.heapFloat[r11 + 1];
                                                f4 = heapClassInst.heapFloat[r11 + numDefine4];
                                                f5 = heapClassInst.heapFloat[r11 + numDefine5];
                                                f1 = f1 * f0;
                                                f3 = f3 * f2;
                                                f6 = heapClassInst.heapFloat[r14 + numDefine2];
                                                f7 = heapClassInst.heapFloat[r11 + numDefine2];
                                                f8 = heapClassInst.heapFloat[r11 + numDefine8];
                                                f9 = heapClassInst.heapFloat[r11 + numDefine9];
                                                f10 = heapClassInst.heapFloat[r11 + numDefine6];
                                                f4 = f4 * f0;
                                                f5 = f5 * f2;
                                                f1 = f1 + f3;
                                                f3 = f7 * f6;
                                                f7 = heapClassInst.heapFloat[r11 + numDefine10];
                                                f0 = f8 * f0;
                                                f2 = f9 * f2;
                                                f4 = f4 + f5;
                                                f5 = f10 * f6;
                                                f1 = f1 + f3;
                                                f3 = heapClassInst.heapFloat[r11 + numDefine12];
                                                f8 = heapClassInst.heapFloat[r11 + numDefine14];
                                                f9 = heapClassInst.heapFloat[r11 + numDefine13];
                                                f4 = f4 + f5;
                                                f0 = f0 + f2;
                                                f2 = f7 * f6;
                                                f1 = f1 + f3;
                                                f0 = f0 + f2;
                                                f2 = f4 + f9;
                                                heapClassInst.heapFloat[fp + numDefineNeg118] = f1;
                                                f0 = f0 + f8;
                                                heapClassInst.heapFloat[r14 + 1] = f2;
                                                heapClassInst.heapFloat[r14 + numDefine2] = f0;
                                                heapClassInst.heap32[r14 + numDefine3] = 0;
                                                r15 = heapClassInst.heap32[r1];
                                                r15 = r15 >> numDefine2;
                                                r15 = heapClassInst.heap32[r15 + numDefine4];
                                                heapClassInst.heap32[g0] = r0;
                                                functionTable.get(r15 >> numDefine2).accept(i7);
                                                r16 = commonVariable.rg0 >> numDefine2;
                                                r16 = heapClassInst.heap32[r16];
                                                r16 = r16 >> numDefine2;
                                                r16 = heapClassInst.heap32[r16 + numDefine2];
                                                r17 = sp + numDefineNeg152;
                                                r18 = r17 >> numDefine2;
                                                heapClassInst.heap32[fp + numDefineNeg38] = 0;
                                                heapClassInst.heap32[r18 + 1] = 0;
                                                heapClassInst.heap32[r18 + numDefine2] = 0;
                                                heapClassInst.heap32[r18 + numDefine3] = 0;
                                                heapClassInst.heap32[g0] = commonVariable.rg0;
                                                heapClassInst.heap32[g0 + 1] = r8;
                                                heapClassInst.heap32[g0 + numDefine2] = r13;
                                                heapClassInst.heap32[g0 + numDefine3] = r17;
                                                r15 = r12 & numDefine3;
                                                functionTable.get(r16 >> numDefine2).accept(i7);
                                                if (!(r15 != 0)) {
                                                    r15 = heapClassInst.heap32[r1];
                                                    r15 = r15 >> numDefine2;
                                                    r15 = heapClassInst.heap32[r15 + numDefine4];
                                                    heapClassInst.heap32[g0] = r0;
                                                    functionTable.get(r15 >> numDefine2).accept(i7);
                                                    r16 = commonVariable.rg0 >> numDefine2;
                                                    r16 = heapClassInst.heap32[r16];
                                                    r16 = r16 >> numDefine2;
                                                    r16 = heapClassInst.heap32[r16 + numDefine2];
                                                    r17 = sp + numDefineNeg136;
                                                    r18 = r17 >> numDefine2;
                                                    heapClassInst.heap32[fp + numDefineNeg34] = 0;
                                                    heapClassInst.heap32[r18 + 1] = 0;
                                                    heapClassInst.heap32[r18 + numDefine2] = 0;
                                                    heapClassInst.heap32[r18 + numDefine3] = 0;
                                                    heapClassInst.heap32[g0] = commonVariable.rg0;
                                                    heapClassInst.heap32[g0 + 1] = r6;
                                                    heapClassInst.heap32[g0 + numDefine2] = r13;
                                                    heapClassInst.heap32[g0 + numDefine3] = r17;
                                                    functionTable.get(r16 >> numDefine2).accept(i7);
                                                }
                                                heapClassInst.heap32[fp + numDefineNeg102] = heapClassInst.heap32[fp + numDefineNeg118];
                                                heapClassInst.heap32[r9 + 1] = heapClassInst.heap32[r14 + 1];
                                                r12 = (r12 + 1) | 0;
                                                heapClassInst.heap32[r9 + numDefine2] = heapClassInst.heap32[r14 + numDefine2];
                                                heapClassInst.heap32[r9 + numDefine3] = heapClassInst.heap32[r14 + numDefine3];
                                                if (!(r12 != numDefine32)) {
                                                    break repeat20;
                                                }
                                            }
                                            r2 = heapClassInst.heap32[r10 + numDefine6];
                                            f0 = heapClassInst.heapFloat[r10 + numDefine110];
                                            heapClassInst.heapFloat[fp + numDefineNeg193] = f0;
                                            f0 = heapClassInst.heapFloat[r10 + numDefine125];
                                            heapClassInst.heapFloat[fp + numDefineNeg194] = f0;
                                            r2 = r2 >> numDefine2;
                                            f0 = heapClassInst.heapFloat[r2 + numDefine84];
                                            f1 = heapClassInst.heapFloat[fp + numDefineNeg192];
                                            if (f0 <= f1) {
                                                r2 = heapClassInst.heap32[r10 + numDefine5];
                                                r2 = r2 >> numDefine2;
                                                f0 = heapClassInst.heapFloat[r10 + numDefine84];
                                                f1 = heapClassInst.heapFloat[r2 + numDefine9];
                                                f2 = heapClassInst.heapFloat[r2 + numDefine5];
                                                f3 = heapClassInst.heapFloat[r2 + 1];
                                                f4 = heapClassInst.heapFloat[r10 + numDefine85];
                                                f5 = heapClassInst.heapFloat[r2 + numDefine10];
                                                f6 = heapClassInst.heapFloat[r2 + numDefine6];
                                                f8 = heapClassInst.heapFloat[r2 + numDefine2];
                                                f12 = heapClassInst.heapFloat[r10 + numDefine74];
                                                f13 = heapClassInst.heapFloat[r10 + numDefine78];
                                                f14 = heapClassInst.heapFloat[r10 + numDefine73];
                                                f15 = heapClassInst.heapFloat[r10 + numDefine77];
                                                f7 = heapClassInst.heapFloat[r10 + numDefine72];
                                                f9 = heapClassInst.heapFloat[r10 + numDefine76];
                                                f10 = f1 * f0;
                                                f11 = f5 * f4;
                                                f16 = f2 * f0;
                                                f17 = f6 * f4;
                                                f0 = f3 * f0;
                                                f4 = f8 * f4;
                                                f18 = heapClassInst.heapFloat[r10 + numDefine86];
                                                f19 = heapClassInst.heapFloat[r2 + numDefine11];
                                                f20 = heapClassInst.heapFloat[r2 + numDefine7];
                                                f21 = heapClassInst.heapFloat[r2 + numDefine3];
                                                f22 = heapClassInst.heapFloat[r10 + numDefine82];
                                                f23 = heapClassInst.heapFloat[r10 + numDefine81];
                                                f24 = heapClassInst.heapFloat[r10 + numDefine80];
                                                f10 = f10 + f11;
                                                f11 = f19 * f18;
                                                f16 = f16 + f17;
                                                f17 = f20 * f18;
                                                f0 = f0 + f4;
                                                heapClassInst.heapFloat[fp + numDefineNeg192] = f0;
                                                f4 = f21 * f18;
                                                f18 = f12 * f1;
                                                f25 = f13 * f5;
                                                f26 = f14 * f1;
                                                f27 = f15 * f5;
                                                f1 = f7 * f1;
                                                f5 = f9 * f5;
                                                f28 = f12 * f2;
                                                f29 = f13 * f6;
                                                f30 = f14 * f2;
                                                f0 = f15 * f6;
                                                f2 = f7 * f2;
                                                f6 = f9 * f6;
                                                f12 = f12 * f3;
                                                f13 = f13 * f8;
                                                f14 = f14 * f3;
                                                f15 = f15 * f8;
                                                f3 = f7 * f3;
                                                f8 = f9 * f8;
                                                f7 = f10 + f11;
                                                f9 = heapClassInst.heapFloat[r2 + numDefine15];
                                                f10 = f16 + f17;
                                                f11 = heapClassInst.heapFloat[r2 + numDefine14];
                                                f16 = heapClassInst.heapFloat[fp + numDefineNeg192];
                                                f4 = f16 + f4;
                                                f16 = heapClassInst.heapFloat[r2 + numDefine13];
                                                f17 = f18 + f25;
                                                f18 = f22 * f19;
                                                f25 = f26 + f27;
                                                f26 = f23 * f19;
                                                f1 = f1 + f5;
                                                f5 = f24 * f19;
                                                f19 = f28 + f29;
                                                f27 = f22 * f20;
                                                f0 = f30 + f0;
                                                f28 = f23 * f20;
                                                f2 = f2 + f6;
                                                f6 = f24 * f20;
                                                f20 = f12 + f13;
                                                f22 = f22 * f21;
                                                f29 = f14 + f15;
                                                f23 = f23 * f21;
                                                f3 = f3 + f8;
                                                f21 = f24 * f21;
                                                f12 = f7 + f9;
                                                f13 = f10 + f11;
                                                f4 = f4 + f16;
                                                f14 = f17 + f18;
                                                f15 = f25 + f26;
                                                f1 = f1 + f5;
                                                f5 = f19 + f27;
                                                f0 = f0 + f28;
                                                f2 = f2 + f6;
                                                f6 = f20 + f22;
                                                f8 = f29 + f23;
                                                f3 = f3 + f21;
                                            } else {
                                                f0 = heapClassInst.heapFloat[r10 + numDefine100];
                                                f1 = heapClassInst.heapFloat[r2 + numDefine9];
                                                f2 = heapClassInst.heapFloat[r2 + numDefine5];
                                                f3 = heapClassInst.heapFloat[r2 + 1];
                                                f4 = heapClassInst.heapFloat[r10 + numDefine101];
                                                f5 = heapClassInst.heapFloat[r2 + numDefine10];
                                                f6 = heapClassInst.heapFloat[r2 + numDefine6];
                                                f7 = heapClassInst.heapFloat[r2 + numDefine2];
                                                f8 = heapClassInst.heapFloat[r10 + numDefine90];
                                                f9 = heapClassInst.heapFloat[r10 + numDefine94];
                                                f10 = heapClassInst.heapFloat[r10 + numDefine89];
                                                f11 = heapClassInst.heapFloat[r10 + numDefine93];
                                                f12 = heapClassInst.heapFloat[r10 + numDefine88];
                                                f13 = heapClassInst.heapFloat[r10 + numDefine92];
                                                f14 = f1 * f0;
                                                f15 = f5 * f4;
                                                f16 = f2 * f0;
                                                f17 = f6 * f4;
                                                f0 = f3 * f0;
                                                f4 = f7 * f4;
                                                f18 = heapClassInst.heapFloat[r10 + numDefine102];
                                                f19 = heapClassInst.heapFloat[r2 + numDefine11];
                                                f20 = heapClassInst.heapFloat[r2 + numDefine7];
                                                f21 = heapClassInst.heapFloat[r2 + numDefine3];
                                                f22 = heapClassInst.heapFloat[r10 + numDefine98];
                                                f23 = heapClassInst.heapFloat[r10 + numDefine97];
                                                f24 = heapClassInst.heapFloat[r10 + numDefine96];
                                                f14 = f14 + f15;
                                                f15 = f19 * f18;
                                                f16 = f16 + f17;
                                                f17 = f20 * f18;
                                                f0 = f0 + f4;
                                                heapClassInst.heapFloat[fp + numDefineNeg192] = f0;
                                                f4 = f21 * f18;
                                                f18 = f8 * f1;
                                                f25 = f9 * f5;
                                                f26 = f10 * f1;
                                                f27 = f11 * f5;
                                                f1 = f12 * f1;
                                                f5 = f13 * f5;
                                                f28 = f8 * f2;
                                                f29 = f9 * f6;
                                                f30 = f10 * f2;
                                                f0 = f11 * f6;
                                                f2 = f12 * f2;
                                                f6 = f13 * f6;
                                                f8 = f8 * f3;
                                                f9 = f9 * f7;
                                                f10 = f10 * f3;
                                                f11 = f11 * f7;
                                                f3 = f12 * f3;
                                                f7 = f13 * f7;
                                                f12 = f14 + f15;
                                                f13 = heapClassInst.heapFloat[r2 + numDefine15];
                                                f14 = f16 + f17;
                                                f15 = heapClassInst.heapFloat[r2 + numDefine14];
                                                f16 = heapClassInst.heapFloat[fp + numDefineNeg192];
                                                f4 = f16 + f4;
                                                f16 = heapClassInst.heapFloat[r2 + numDefine13];
                                                f17 = f18 + f25;
                                                f18 = f22 * f19;
                                                f25 = f26 + f27;
                                                f26 = f23 * f19;
                                                f1 = f1 + f5;
                                                f5 = f24 * f19;
                                                f19 = f28 + f29;
                                                f27 = f22 * f20;
                                                f0 = f30 + f0;
                                                f28 = f23 * f20;
                                                f2 = f2 + f6;
                                                f6 = f24 * f20;
                                                f8 = f8 + f9;
                                                f9 = f22 * f21;
                                                f10 = f10 + f11;
                                                f11 = f23 * f21;
                                                f3 = f3 + f7;
                                                f7 = f24 * f21;
                                                f12 = f12 + f13;
                                                f13 = f14 + f15;
                                                f4 = f4 + f16;
                                                f14 = f17 + f18;
                                                f15 = f25 + f26;
                                                f1 = f1 + f5;
                                                f5 = f19 + f27;
                                                f0 = f0 + f28;
                                                f2 = f2 + f6;
                                                f6 = f8 + f9;
                                                f8 = f10 + f11;
                                                f3 = f3 + f7;
                                            }
                                            heapClassInst.heapFloat[fp + numDefineNeg98] = f3;
                                            heapClassInst.heapFloat[r11 + 1] = f8;
                                            heapClassInst.heapFloat[r11 + numDefine2] = f6;
                                            heapClassInst.heap32[r11 + numDefine3] = 0;
                                            heapClassInst.heapFloat[r11 + numDefine4] = f2;
                                            heapClassInst.heapFloat[r11 + numDefine5] = f0;
                                            heapClassInst.heapFloat[r11 + numDefine6] = f5;
                                            heapClassInst.heap32[r11 + numDefine7] = 0;
                                            heapClassInst.heapFloat[r11 + numDefine8] = f1;
                                            heapClassInst.heapFloat[r11 + numDefine9] = f15;
                                            heapClassInst.heapFloat[r11 + numDefine10] = f14;
                                            heapClassInst.heap32[r11 + numDefine11] = 0;
                                            heapClassInst.heapFloat[r11 + numDefine12] = f4;
                                            heapClassInst.heapFloat[r11 + numDefine13] = f13;
                                            heapClassInst.heapFloat[r11 + numDefine14] = f12;
                                            r2 = sp + numDefineNeg424;
                                            heapClassInst.heap32[r11 + numDefine15] = 0;
                                            r8 = r2 >> numDefine2;
                                            heapClassInst.heapFloat[fp + numDefineNeg106] = f4;
                                            heapClassInst.heapFloat[r8 + 1] = f13;
                                            heapClassInst.heapFloat[r8 + numDefine2] = f12;
                                            r9 = sp + numDefineNeg440;
                                            heapClassInst.heap32[r8 + numDefine3] = 0;
                                            r8 = r9 >> numDefine2;
                                            heapClassInst.heapFloat[fp + numDefineNeg110] = f3;
                                            heapClassInst.heapFloat[r8 + 1] = f2;
                                            heapClassInst.heapFloat[r8 + numDefine2] = f1;
                                            r10 = sp + numDefineNeg456;
                                            heapClassInst.heap32[r8 + numDefine3] = 0;
                                            r8 = r10 >> numDefine2;
                                            heapClassInst.heapFloat[fp + numDefineNeg114] = f8;
                                            heapClassInst.heapFloat[r8 + 1] = f0;
                                            heapClassInst.heapFloat[r8 + numDefine2] = f15;
                                            heapClassInst.heap32[r8 + numDefine3] = 0;
                                            r8 = heapClassInst.heap32[r1];
                                            r8 = r8 >> numDefine2;
                                            r8 = heapClassInst.heap32[r8 + numDefine4];
                                            heapClassInst.heap32[g0] = r0;
                                            functionTable.get(r8 >> numDefine2).accept(i7);
                                            r11 = commonVariable.rg0 >> numDefine2;
                                            r11 = heapClassInst.heap32[r11];
                                            r11 = r11 >> numDefine2;
                                            r11 = heapClassInst.heap32[r11 + numDefine15];
                                            r12 = sp + numDefineNeg120;
                                            r13 = r12 >> numDefine2;
                                            heapClassInst.heap32[fp + numDefineNeg30] = 0;
                                            heapClassInst.heap32[r13 + 1] = 0;
                                            heapClassInst.heap32[r13 + numDefine2] = 0;
                                            heapClassInst.heap32[r13 + numDefine3] = 0;
                                            f0 = heapClassInst.heapFloat[fp + numDefineNeg194];
                                            f1 = -f0;
                                            f2 = heapClassInst.heapFloat[fp + numDefineNeg193];
                                            f1 = f1 - f2;
                                            f0 = f2 - f0;
                                            heapClassInst.heap32[g0] = commonVariable.rg0;
                                            heapClassInst.heap32[g0 + 1] = r2;
                                            heapClassInst.heap32[g0 + numDefine2] = r9;
                                            heapClassInst.heap32[g0 + numDefine3] = r10;
                                            f2 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                            heapClassInst.heapFloat[g0 + numDefine4] = f2;
                                            heapClassInst.heapFloat[g0 + numDefine5] = f2;
                                            heapClassInst.heapFloat[g0 + numDefine6] = f1;
                                            heapClassInst.heapFloat[g0 + numDefine7] = f0;
                                            heapClassInst.heap32[g0 + numDefine8] = r12;
                                            heapClassInst.heap32[g0 + numDefine9] = 1;
                                            heapClassInst.heap32[g0 + numDefine10] = (int) numDefine16192;
                                            functionTable.get(r11 >> numDefine2).accept(i7);
                                        }
                                    } else {
                                        if (r11 == numDefine6) {
                                            r11 = sp + numDefineNeg536;
                                            r12 = r11 >> numDefine2;
                                            heapClassInst.heap32[fp + numDefineNeg134] = heapClassInst.heap32[r10 + numDefine263];
                                            heapClassInst.heap32[r12 + 1] = heapClassInst.heap32[r10 + numDefine264];
                                            heapClassInst.heap32[r12 + numDefine2] = heapClassInst.heap32[r10 + numDefine265];
                                            heapClassInst.heap32[r12 + numDefine3] = heapClassInst.heap32[r10 + numDefine266];
                                            heapClassInst.heap32[r12 + numDefine4] = heapClassInst.heap32[r10 + numDefine267];
                                            heapClassInst.heap32[r12 + numDefine5] = heapClassInst.heap32[r10 + numDefine268];
                                            heapClassInst.heap32[r12 + numDefine6] = heapClassInst.heap32[r10 + numDefine269];
                                            heapClassInst.heap32[r12 + numDefine7] = heapClassInst.heap32[r10 + numDefine270];
                                            heapClassInst.heap32[r12 + numDefine8] = heapClassInst.heap32[r10 + numDefine271];
                                            heapClassInst.heap32[r12 + numDefine9] = heapClassInst.heap32[r10 + numDefine272];
                                            heapClassInst.heap32[r12 + numDefine10] = heapClassInst.heap32[r10 + numDefine273];
                                            heapClassInst.heap32[r12 + numDefine11] = heapClassInst.heap32[r10 + numDefine274];
                                            heapClassInst.heap32[r12 + numDefine12] = heapClassInst.heap32[r10 + numDefine275];
                                            heapClassInst.heap32[r12 + numDefine13] = heapClassInst.heap32[r10 + numDefine276];
                                            heapClassInst.heap32[r12 + numDefine14] = heapClassInst.heap32[r10 + numDefine277];
                                            heapClassInst.heap32[r12 + numDefine15] = heapClassInst.heap32[r10 + numDefine278];
                                            if (!(r8 == 0)) {
                                                r13 = heapClassInst.heap32[r1];
                                                r13 = r13 >> numDefine2;
                                                r13 = heapClassInst.heap32[r13 + numDefine4];
                                                heapClassInst.heap32[g0] = r0;
                                                functionTable.get(r13 >> numDefine2).accept(i7);
                                                r14 = commonVariable.rg0 >> numDefine2;
                                                r14 = heapClassInst.heap32[r14];
                                                r14 = r14 >> numDefine2;
                                                r14 = heapClassInst.heap32[r14 + numDefine14];
                                                heapClassInst.heap32[g0] = commonVariable.rg0;
                                                heapClassInst.heap32[g0 + 1] = r11;
                                                f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                                heapClassInst.heapFloat[g0 + numDefine2] = f0;
                                                functionTable.get(r14 >> numDefine2).accept(i7);
                                            }
                                            heapClassInst.heap32[fp + numDefineNeg134] = heapClassInst.heap32[r10 + numDefine279];
                                            heapClassInst.heap32[r12 + 1] = heapClassInst.heap32[r10 + numDefine280];
                                            heapClassInst.heap32[r12 + numDefine2] = heapClassInst.heap32[r10 + numDefine281];
                                            heapClassInst.heap32[r12 + numDefine3] = heapClassInst.heap32[r10 + numDefine282];
                                            heapClassInst.heap32[r12 + numDefine4] = heapClassInst.heap32[r10 + numDefine283];
                                            heapClassInst.heap32[r12 + numDefine5] = heapClassInst.heap32[r10 + numDefine284];
                                            heapClassInst.heap32[r12 + numDefine6] = heapClassInst.heap32[r10 + numDefine285];
                                            heapClassInst.heap32[r12 + numDefine7] = heapClassInst.heap32[r10 + numDefine286];
                                            heapClassInst.heap32[r12 + numDefine8] = heapClassInst.heap32[r10 + numDefine287];
                                            heapClassInst.heap32[r12 + numDefine9] = heapClassInst.heap32[r10 + numDefine288];
                                            heapClassInst.heap32[r12 + numDefine10] = heapClassInst.heap32[r10 + numDefine289];
                                            heapClassInst.heap32[r12 + numDefine11] = heapClassInst.heap32[r10 + numDefine290];
                                            heapClassInst.heap32[r12 + numDefine12] = heapClassInst.heap32[r10 + numDefine291];
                                            heapClassInst.heap32[r12 + numDefine13] = heapClassInst.heap32[r10 + numDefine292];
                                            heapClassInst.heap32[r12 + numDefine14] = heapClassInst.heap32[r10 + numDefine293];
                                            heapClassInst.heap32[r12 + numDefine15] = heapClassInst.heap32[r10 + numDefine294];
                                            if (!(r8 == 0)) {
                                                r8 = heapClassInst.heap32[r1];
                                                r8 = r8 >> numDefine2;
                                                r8 = heapClassInst.heap32[r8 + numDefine4];
                                                heapClassInst.heap32[g0] = r0;
                                                functionTable.get(r8 >> numDefine2).accept(i7);
                                                r13 = commonVariable.rg0 >> numDefine2;
                                                r13 = heapClassInst.heap32[r13];
                                                r13 = r13 >> numDefine2;
                                                r13 = heapClassInst.heap32[r13 + numDefine14];
                                                heapClassInst.heap32[g0] = commonVariable.rg0;
                                                heapClassInst.heap32[g0 + 1] = r11;
                                                f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                                heapClassInst.heapFloat[g0 + numDefine2] = f0;
                                                functionTable.get(r13 >> numDefine2).accept(i7);
                                            }
                                            if (r9 == 0) {
                                                break repeat7;
                                            } else {
                                                r2 = (r2 + numDefine1164) | 0;
                                                f0 = heapClassInst.heapFloat[r10 + numDefine263];
                                                heapClassInst.heapFloat[fp + numDefineNeg134] = f0;
                                                heapClassInst.heap32[r12 + 1] = heapClassInst.heap32[r10 + numDefine264];
                                                f1 = heapClassInst.heapFloat[r10 + numDefine265];
                                                heapClassInst.heapFloat[r12 + numDefine2] = f1;
                                                heapClassInst.heap32[r12 + numDefine3] = heapClassInst.heap32[r10 + numDefine266];
                                                f2 = heapClassInst.heapFloat[r10 + numDefine267];
                                                heapClassInst.heapFloat[r12 + numDefine4] = f2;
                                                heapClassInst.heap32[r12 + numDefine5] = heapClassInst.heap32[r10 + numDefine268];
                                                f3 = heapClassInst.heapFloat[r10 + numDefine269];
                                                heapClassInst.heapFloat[r12 + numDefine6] = f3;
                                                heapClassInst.heap32[r12 + numDefine7] = heapClassInst.heap32[r10 + numDefine270];
                                                f4 = heapClassInst.heapFloat[r10 + numDefine271];
                                                heapClassInst.heapFloat[r12 + numDefine8] = f4;
                                                heapClassInst.heap32[r12 + numDefine9] = heapClassInst.heap32[r10 + numDefine272];
                                                f5 = heapClassInst.heapFloat[r10 + numDefine273];
                                                heapClassInst.heapFloat[r12 + numDefine10] = f5;
                                                heapClassInst.heap32[r12 + numDefine11] = heapClassInst.heap32[r10 + numDefine274];
                                                heapClassInst.heap32[r12 + numDefine12] = heapClassInst.heap32[r10 + numDefine275];
                                                heapClassInst.heap32[r12 + numDefine13] = heapClassInst.heap32[r10 + numDefine276];
                                                heapClassInst.heap32[r12 + numDefine14] = heapClassInst.heap32[r10 + numDefine277];
                                                r8 = sp + numDefineNeg552;
                                                heapClassInst.heap32[r12 + numDefine15] = heapClassInst.heap32[r10 + numDefine278];
                                                r9 = r8 >> numDefine2;
                                                heapClassInst.heapFloat[fp + numDefineNeg138] = f1;
                                                heapClassInst.heapFloat[r9 + 1] = f3;
                                                heapClassInst.heapFloat[r9 + numDefine2] = f5;
                                                heapClassInst.heap32[r9 + numDefine3] = 0;
                                                r9 = sp + numDefineNeg568;
                                                heapClassInst.heapFloat[fp + numDefineNeg142] = f0;
                                                r13 = r9 >> numDefine2;
                                                heapClassInst.heapFloat[r13 + 1] = f2;
                                                heapClassInst.heapFloat[r13 + numDefine2] = f4;
                                                heapClassInst.heap32[r13 + numDefine3] = 0;
                                                r14 = heapClassInst.heap32[r1];
                                                r14 = r14 >> numDefine2;
                                                r14 = heapClassInst.heap32[r14 + numDefine4];
                                                f0 = heapClassInst.heapFloat[r10 + numDefine230];
                                                f1 = heapClassInst.heapFloat[r10 + numDefine231];
                                                f2 = heapClassInst.heapFloat[r10 + numDefine246];
                                                f3 = heapClassInst.heapFloat[r10 + numDefine247];
                                                heapClassInst.heap32[g0] = r0;
                                                functionTable.get(r14 >> numDefine2).accept(i7);
                                                r15 = commonVariable.rg0 >> numDefine2;
                                                r15 = heapClassInst.heap32[r15];
                                                r15 = r15 >> numDefine2;
                                                r15 = heapClassInst.heap32[r15 + numDefine16];
                                                r16 = sp + numDefineNeg104;
                                                r17 = r16 >> numDefine2;
                                                heapClassInst.heap32[fp + numDefineNeg26] = 0;
                                                heapClassInst.heap32[r17 + 1] = 0;
                                                heapClassInst.heap32[r17 + numDefine2] = 0;
                                                heapClassInst.heap32[r17 + numDefine3] = 0;
                                                f4 = (float) numDefineFloat809;
                                                f5 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                                f4 = f5 * f4;
                                                heapClassInst.heap32[g0] = commonVariable.rg0;
                                                heapClassInst.heap32[g0 + 1] = r2;
                                                heapClassInst.heap32[g0 + numDefine2] = r8;
                                                heapClassInst.heap32[g0 + numDefine3] = r9;
                                                heapClassInst.heapFloat[g0 + numDefine4] = f4;
                                                heapClassInst.heapFloat[g0 + numDefine5] = f0;
                                                heapClassInst.heapFloat[g0 + numDefine6] = f1;
                                                heapClassInst.heapFloat[g0 + numDefine7] = f2;
                                                heapClassInst.heapFloat[g0 + numDefine8] = f3;
                                                heapClassInst.heap32[g0 + numDefine9] = r16;
                                                heapClassInst.heap32[g0 + numDefine10] = (int) numDefine16192;
                                                functionTable.get(r15 >> numDefine2).accept(i7);
                                                f0 = heapClassInst.heapFloat[r12 + numDefine9];
                                                f1 = heapClassInst.heapFloat[r12 + numDefine5];
                                                heapClassInst.heap32[fp + numDefineNeg142] = heapClassInst.heap32[r12 + 1];
                                                heapClassInst.heapFloat[r13 + 1] = f1;
                                                heapClassInst.heapFloat[r13 + numDefine2] = f0;
                                                heapClassInst.heap32[r13 + numDefine3] = 0;
                                                f0 = heapClassInst.heapFloat[r10 + numDefine296];
                                                f1 = heapClassInst.heapFloat[r10 + numDefine297];
                                                heapClassInst.heapFloat[g0] = f0;
                                                cosf(i7);
                                                f2 = (float) commonVariable.fg0;
                                                heapClassInst.heapFloat[g0] = f0;
                                                sinf(i7);
                                                f0 = (float) commonVariable.fg0;
                                                heapClassInst.heapFloat[g0] = f1;
                                                cosf(i7);
                                                f3 = (float) commonVariable.fg0;
                                                heapClassInst.heapFloat[g0] = f1;
                                                sinf(i7);
                                                f4 = heapClassInst.heapFloat[fp + numDefineNeg142];
                                                f5 = f2 * f3;
                                                f6 = heapClassInst.heapFloat[r13 + 1];
                                                f7 = (float) (f2 * commonVariable.fg0);
                                                f8 = heapClassInst.heapFloat[r13 + numDefine2];
                                                f5 = f5 * f4;
                                                f7 = f7 * f6;
                                                f9 = f3 * f0;
                                                f10 = (float) (commonVariable.fg0 * f0);
                                                f5 = f5 + f7;
                                                f0 = f8 * f0;
                                                r8 = sp + numDefineNeg584;
                                                f7 = f9 * f4;
                                                f9 = f10 * f6;
                                                f3 = f6 * f3;
                                                f1 = (float) (f4 * commonVariable.fg0);
                                                f0 = f5 - f0;
                                                r9 = r8 >> numDefine2;
                                                f4 = f7 + f9;
                                                f2 = f8 * f2;
                                                f1 = f3 - f1;
                                                heapClassInst.heapFloat[fp + numDefineNeg146] = f0;
                                                f0 = f4 + f2;
                                                heapClassInst.heapFloat[r9 + 1] = f1;
                                                heapClassInst.heapFloat[r9 + numDefine2] = f0;
                                                f0 = heapClassInst.heapFloat[r10 + numDefine279];
                                                heapClassInst.heapFloat[fp + numDefineNeg134] = f0;
                                                heapClassInst.heap32[r12 + 1] = heapClassInst.heap32[r10 + numDefine280];
                                                heapClassInst.heap32[r12 + numDefine2] = heapClassInst.heap32[r10 + numDefine281];
                                                heapClassInst.heap32[r12 + numDefine3] = heapClassInst.heap32[r10 + numDefine282];
                                                f1 = heapClassInst.heapFloat[r10 + numDefine283];
                                                heapClassInst.heapFloat[r12 + numDefine4] = f1;
                                                heapClassInst.heap32[r12 + numDefine5] = heapClassInst.heap32[r10 + numDefine284];
                                                heapClassInst.heap32[r12 + numDefine6] = heapClassInst.heap32[r10 + numDefine285];
                                                heapClassInst.heap32[r12 + numDefine7] = heapClassInst.heap32[r10 + numDefine286];
                                                f2 = heapClassInst.heapFloat[r10 + numDefine287];
                                                heapClassInst.heapFloat[r12 + numDefine8] = f2;
                                                heapClassInst.heap32[r12 + numDefine9] = heapClassInst.heap32[r10 + numDefine288];
                                                heapClassInst.heap32[r12 + numDefine10] = heapClassInst.heap32[r10 + numDefine289];
                                                heapClassInst.heap32[r12 + numDefine11] = heapClassInst.heap32[r10 + numDefine290];
                                                heapClassInst.heap32[r12 + numDefine12] = heapClassInst.heap32[r10 + numDefine291];
                                                heapClassInst.heap32[r12 + numDefine13] = heapClassInst.heap32[r10 + numDefine292];
                                                heapClassInst.heap32[r12 + numDefine14] = heapClassInst.heap32[r10 + numDefine293];
                                                r9 = sp + numDefineNeg600;
                                                f0 = -f0;
                                                heapClassInst.heap32[r12 + numDefine15] = heapClassInst.heap32[r10 + numDefine294];
                                                r13 = r9 >> numDefine2;
                                                f1 = -f1;
                                                heapClassInst.heapFloat[fp + numDefineNeg150] = f0;
                                                f0 = -f2;
                                                heapClassInst.heapFloat[r13 + 1] = f1;
                                                heapClassInst.heapFloat[r13 + numDefine2] = f0;
                                                heapClassInst.heap32[r13 + numDefine3] = 0;
                                                f0 = heapClassInst.heapFloat[r10 + numDefine214];
                                                f1 = heapClassInst.heapFloat[r10 + numDefine215];
                                                if (f0 <= f1) {
                                                    if (!(f0 >= f1)) {
                                                        r13 = heapClassInst.heap32[r1];
                                                        r13 = r13 >> numDefine2;
                                                        r13 = heapClassInst.heap32[r13 + numDefine4];
                                                        heapClassInst.heap32[g0] = r0;
                                                        functionTable.get(r13 >> numDefine2).accept(i7);
                                                        r14 = commonVariable.rg0 >> numDefine2;
                                                        r14 = heapClassInst.heap32[r14];
                                                        r14 = r14 >> numDefine2;
                                                        r14 = heapClassInst.heap32[r14 + numDefine15];
                                                        r15 = sp + numDefineNeg72;
                                                        r16 = r15 >> numDefine2;
                                                        heapClassInst.heap32[fp + numDefineNeg18] = 0;
                                                        heapClassInst.heap32[r16 + 1] = 0;
                                                        heapClassInst.heap32[r16 + numDefine2] = 0;
                                                        heapClassInst.heap32[r16 + numDefine3] = 0;
                                                        heapClassInst.heap32[g0] = commonVariable.rg0;
                                                        heapClassInst.heap32[g0 + 1] = r2;
                                                        heapClassInst.heap32[g0 + numDefine2] = r9;
                                                        heapClassInst.heap32[g0 + numDefine3] = r8;
                                                        f2 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                                        heapClassInst.heapFloat[g0 + numDefine4] = f2;
                                                        heapClassInst.heapFloat[g0 + numDefine5] = f2;
                                                        heapClassInst.heapFloat[g0 + numDefine6] = f0;
                                                        heapClassInst.heapFloat[g0 + numDefine7] = f1;
                                                        heapClassInst.heap32[g0 + numDefine8] = r15;
                                                        heapClassInst.heap32[g0 + numDefine9] = 1;
                                                        heapClassInst.heap32[g0 + numDefine10] = (int) numDefine16192;
                                                        functionTable.get(r14 >> numDefine2).accept(i7);
                                                    }
                                                } else {
                                                    r13 = heapClassInst.heap32[r1];
                                                    r13 = r13 >> numDefine2;
                                                    r13 = heapClassInst.heap32[r13 + numDefine4];
                                                    heapClassInst.heap32[g0] = r0;
                                                    functionTable.get(r13 >> numDefine2).accept(i7);
                                                    r14 = commonVariable.rg0 >> numDefine2;
                                                    r14 = heapClassInst.heap32[r14];
                                                    r14 = r14 >> numDefine2;
                                                    r14 = heapClassInst.heap32[r14 + numDefine15];
                                                    r15 = sp + numDefineNeg88;
                                                    r16 = r15 >> numDefine2;
                                                    heapClassInst.heap32[fp + numDefineNeg22] = 0;
                                                    heapClassInst.heap32[r16 + 1] = 0;
                                                    heapClassInst.heap32[r16 + numDefine2] = 0;
                                                    heapClassInst.heap32[r16 + numDefine3] = 0;
                                                    heapClassInst.heap32[g0] = commonVariable.rg0;
                                                    heapClassInst.heap32[g0 + 1] = r2;
                                                    heapClassInst.heap32[g0 + numDefine2] = r9;
                                                    heapClassInst.heap32[g0 + numDefine3] = r8;
                                                    f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                                    heapClassInst.heapFloat[g0 + numDefine4] = f0;
                                                    heapClassInst.heapFloat[g0 + numDefine5] = f0;
                                                    heapClassInst.heap32[g0 + numDefine6] = (int) numDefineNeg53637;
                                                    heapClassInst.heap32[g0 + numDefine7] = (int) numDefine30011;
                                                    heapClassInst.heap32[g0 + numDefine8] = r15;
                                                    heapClassInst.heap32[g0 + numDefine9] = 0;
                                                    heapClassInst.heap32[g0 + numDefine10] = (int) numDefine16192;
                                                    functionTable.get(r14 >> numDefine2).accept(i7);
                                                }
                                                heapClassInst.heap32[fp + numDefineNeg134] = heapClassInst.heap32[r10 + numDefine263];
                                                heapClassInst.heap32[r12 + 1] = heapClassInst.heap32[r10 + numDefine264];
                                                heapClassInst.heap32[r12 + numDefine2] = heapClassInst.heap32[r10 + numDefine265];
                                                heapClassInst.heap32[r12 + numDefine3] = heapClassInst.heap32[r10 + numDefine266];
                                                heapClassInst.heap32[r12 + numDefine4] = heapClassInst.heap32[r10 + numDefine267];
                                                heapClassInst.heap32[r12 + numDefine5] = heapClassInst.heap32[r10 + numDefine268];
                                                heapClassInst.heap32[r12 + numDefine6] = heapClassInst.heap32[r10 + numDefine269];
                                                heapClassInst.heap32[r12 + numDefine7] = heapClassInst.heap32[r10 + numDefine270];
                                                heapClassInst.heap32[r12 + numDefine8] = heapClassInst.heap32[r10 + numDefine271];
                                                heapClassInst.heap32[r12 + numDefine9] = heapClassInst.heap32[r10 + numDefine272];
                                                heapClassInst.heap32[r12 + numDefine10] = heapClassInst.heap32[r10 + numDefine273];
                                                heapClassInst.heap32[r12 + numDefine11] = heapClassInst.heap32[r10 + numDefine274];
                                                heapClassInst.heap32[r12 + numDefine12] = heapClassInst.heap32[r10 + numDefine275];
                                                heapClassInst.heap32[r12 + numDefine13] = heapClassInst.heap32[r10 + numDefine276];
                                                heapClassInst.heap32[r12 + numDefine14] = heapClassInst.heap32[r10 + numDefine277];
                                                r2 = sp + numDefineNeg616;
                                                heapClassInst.heap32[r12 + numDefine15] = heapClassInst.heap32[r10 + numDefine278];
                                                r8 = r2 >> numDefine2;
                                                heapClassInst.heap32[fp + numDefineNeg154] = heapClassInst.heap32[r10 + numDefine167];
                                                heapClassInst.heap32[r8 + 1] = heapClassInst.heap32[r10 + numDefine168];
                                                heapClassInst.heap32[r8 + numDefine2] = heapClassInst.heap32[r10 + numDefine169];
                                                r9 = sp + numDefineNeg632;
                                                heapClassInst.heap32[r8 + numDefine3] = heapClassInst.heap32[r10 + numDefine170];
                                                r8 = r9 >> numDefine2;
                                                heapClassInst.heap32[fp + numDefineNeg158] = heapClassInst.heap32[r10 + numDefine171];
                                                heapClassInst.heap32[r8 + 1] = heapClassInst.heap32[r10 + numDefine172];
                                                heapClassInst.heap32[r8 + numDefine2] = heapClassInst.heap32[r10 + numDefine173];
                                                heapClassInst.heap32[r8 + numDefine3] = heapClassInst.heap32[r10 + numDefine174];
                                                r8 = heapClassInst.heap32[r1];
                                                r8 = r8 >> numDefine2;
                                                r8 = heapClassInst.heap32[r8 + numDefine4];
                                                heapClassInst.heap32[g0] = r0;
                                                functionTable.get(r8 >> numDefine2).accept(i7);
                                                r10 = commonVariable.rg0 >> numDefine2;
                                                r10 = heapClassInst.heap32[r10];
                                                r10 = r10 >> numDefine2;
                                                r10 = heapClassInst.heap32[r10 + numDefine18];
                                                r12 = sp + numDefineNeg56;
                                                r13 = r12 >> numDefine2;
                                                heapClassInst.heap32[fp + numDefineNeg14] = 0;
                                                heapClassInst.heap32[r13 + 1] = 0;
                                                heapClassInst.heap32[r13 + numDefine2] = 0;
                                                heapClassInst.heap32[r13 + numDefine3] = 0;
                                                heapClassInst.heap32[g0] = commonVariable.rg0;
                                                heapClassInst.heap32[g0 + 1] = r2;
                                                heapClassInst.heap32[g0 + numDefine2] = r9;
                                                heapClassInst.heap32[g0 + numDefine3] = r11;
                                                heapClassInst.heap32[g0 + numDefine4] = r12;
                                                functionTable.get(r10 >> numDefine2).accept(i7);
                                            }
                                        } else {
                                            if (r11 == numDefine7) {
                                                r11 = sp + numDefineNeg696;
                                                r12 = r11 >> numDefine2;
                                                heapClassInst.heap32[fp + numDefineNeg174] = heapClassInst.heap32[r10 + numDefine203];
                                                heapClassInst.heap32[r12 + 1] = heapClassInst.heap32[r10 + numDefine204];
                                                heapClassInst.heap32[r12 + numDefine2] = heapClassInst.heap32[r10 + numDefine205];
                                                heapClassInst.heap32[r12 + numDefine3] = heapClassInst.heap32[r10 + numDefine206];
                                                heapClassInst.heap32[r12 + numDefine4] = heapClassInst.heap32[r10 + numDefine207];
                                                heapClassInst.heap32[r12 + numDefine5] = heapClassInst.heap32[r10 + numDefine208];
                                                heapClassInst.heap32[r12 + numDefine6] = heapClassInst.heap32[r10 + numDefine209];
                                                heapClassInst.heap32[r12 + numDefine7] = heapClassInst.heap32[r10 + numDefine210];
                                                heapClassInst.heap32[r12 + numDefine8] = heapClassInst.heap32[r10 + numDefine211];
                                                heapClassInst.heap32[r12 + numDefine9] = heapClassInst.heap32[r10 + numDefine212];
                                                heapClassInst.heap32[r12 + numDefine10] = heapClassInst.heap32[r10 + numDefine213];
                                                heapClassInst.heap32[r12 + numDefine11] = heapClassInst.heap32[r10 + numDefine214];
                                                heapClassInst.heap32[r12 + numDefine12] = heapClassInst.heap32[r10 + numDefine215];
                                                heapClassInst.heap32[r12 + numDefine13] = heapClassInst.heap32[r10 + numDefine216];
                                                heapClassInst.heap32[r12 + numDefine14] = heapClassInst.heap32[r10 + numDefine217];
                                                heapClassInst.heap32[r12 + numDefine15] = heapClassInst.heap32[r10 + numDefine218];
                                                if (!(r8 == 0)) {
                                                    r13 = heapClassInst.heap32[r1];
                                                    r13 = r13 >> numDefine2;
                                                    r13 = heapClassInst.heap32[r13 + numDefine4];
                                                    heapClassInst.heap32[g0] = r0;
                                                    functionTable.get(r13 >> numDefine2).accept(i7);
                                                    r14 = commonVariable.rg0 >> numDefine2;
                                                    r14 = heapClassInst.heap32[r14];
                                                    r14 = r14 >> numDefine2;
                                                    r14 = heapClassInst.heap32[r14 + numDefine14];
                                                    heapClassInst.heap32[g0] = commonVariable.rg0;
                                                    heapClassInst.heap32[g0 + 1] = r11;
                                                    f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                                    heapClassInst.heapFloat[g0 + numDefine2] = f0;
                                                    functionTable.get(r14 >> numDefine2).accept(i7);
                                                }
                                                heapClassInst.heap32[fp + numDefineNeg174] = heapClassInst.heap32[r10 + numDefine219];
                                                heapClassInst.heap32[r12 + 1] = heapClassInst.heap32[r10 + numDefine220];
                                                heapClassInst.heap32[r12 + numDefine2] = heapClassInst.heap32[r10 + numDefine221];
                                                heapClassInst.heap32[r12 + numDefine3] = heapClassInst.heap32[r10 + numDefine222];
                                                heapClassInst.heap32[r12 + numDefine4] = heapClassInst.heap32[r10 + numDefine223];
                                                heapClassInst.heap32[r12 + numDefine5] = heapClassInst.heap32[r10 + numDefine224];
                                                heapClassInst.heap32[r12 + numDefine6] = heapClassInst.heap32[r10 + numDefine225];
                                                heapClassInst.heap32[r12 + numDefine7] = heapClassInst.heap32[r10 + numDefine226];
                                                heapClassInst.heap32[r12 + numDefine8] = heapClassInst.heap32[r10 + numDefine227];
                                                heapClassInst.heap32[r12 + numDefine9] = heapClassInst.heap32[r10 + numDefine228];
                                                heapClassInst.heap32[r12 + numDefine10] = heapClassInst.heap32[r10 + numDefine229];
                                                heapClassInst.heap32[r12 + numDefine11] = heapClassInst.heap32[r10 + numDefine230];
                                                heapClassInst.heap32[r12 + numDefine12] = heapClassInst.heap32[r10 + numDefine231];
                                                heapClassInst.heap32[r12 + numDefine13] = heapClassInst.heap32[r10 + numDefine232];
                                                heapClassInst.heap32[r12 + numDefine14] = heapClassInst.heap32[r10 + numDefine233];
                                                heapClassInst.heap32[r12 + numDefine15] = heapClassInst.heap32[r10 + numDefine234];
                                                if (!(r8 == 0)) {
                                                    r8 = heapClassInst.heap32[r1];
                                                    r8 = r8 >> numDefine2;
                                                    r8 = heapClassInst.heap32[r8 + numDefine4];
                                                    heapClassInst.heap32[g0] = r0;
                                                    functionTable.get(r8 >> numDefine2).accept(i7);
                                                    r12 = commonVariable.rg0 >> numDefine2;
                                                    r12 = heapClassInst.heap32[r12];
                                                    r12 = r12 >> numDefine2;
                                                    r12 = heapClassInst.heap32[r12 + numDefine14];
                                                    heapClassInst.heap32[g0] = commonVariable.rg0;
                                                    heapClassInst.heap32[g0 + 1] = r11;
                                                    f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                                    heapClassInst.heapFloat[g0 + numDefine2] = f0;
                                                    functionTable.get(r12 >> numDefine2).accept(i7);
                                                }
                                                if (r9 == 0) {
                                                    break repeat7;
                                                } else {
                                                    r8 = (r2 + numDefine924) | 0;
                                                    r9 = heapClassInst.heapU8[r2 + numDefine168];
                                                    if (r9 == 0) {
                                                        r2 = (r2 + numDefine876) | 0;
                                                    } else {
                                                        r2 = (r2 + numDefine812) | 0;
                                                    }
                                                    r2 = r2 >> numDefine2;
                                                    f0 = heapClassInst.heapFloat[r2 + 1];
                                                    f1 = heapClassInst.heapFloat[r10 + numDefine43];
                                                    f2 = heapClassInst.heapFloat[r2];
                                                    f3 = heapClassInst.heapFloat[r2 + numDefine2];
                                                    f4 = heapClassInst.heapFloat[r2 + numDefine5];
                                                    f5 = heapClassInst.heapFloat[r2 + numDefine4];
                                                    f6 = f2 * f1;
                                                    f7 = heapClassInst.heapFloat[fp + numDefineNeg192];
                                                    f8 = f0 * f7;
                                                    f9 = heapClassInst.heapFloat[r2 + numDefine6];
                                                    f10 = heapClassInst.heapFloat[r2 + numDefine9];
                                                    f11 = heapClassInst.heapFloat[r2 + numDefine8];
                                                    f12 = f5 * f1;
                                                    f13 = f4 * f7;
                                                    f6 = f6 + f8;
                                                    f3 = f3 * f7;
                                                    f14 = heapClassInst.heapFloat[r2 + numDefine10];
                                                    f1 = f11 * f1;
                                                    f15 = f10 * f7;
                                                    f12 = f12 + f13;
                                                    f9 = f9 * f7;
                                                    f6 = f6 + f3;
                                                    f16 = heapClassInst.heapFloat[r2 + numDefine12];
                                                    f17 = heapClassInst.heapFloat[r2 + numDefine13];
                                                    f18 = heapClassInst.heapFloat[r2 + numDefine14];
                                                    r2 = sp + numDefineNeg712;
                                                    f12 = f12 + f9;
                                                    f1 = f1 + f15;
                                                    f7 = f14 * f7;
                                                    f6 = f6 + f16;
                                                    f1 = f1 + f7;
                                                    r9 = r2 >> numDefine2;
                                                    f12 = f12 + f17;
                                                    heapClassInst.heapFloat[fp + numDefineNeg178] = f6;
                                                    f1 = f1 + f18;
                                                    heapClassInst.heapFloat[r9 + 1] = f12;
                                                    heapClassInst.heapFloat[r9 + numDefine2] = f1;
                                                    heapClassInst.heap32[r9 + numDefine3] = 0;
                                                    f1 = heapClassInst.heapFloat[r10 + numDefine44];
                                                    f6 = f2 * f1;
                                                    f12 = f5 * f1;
                                                    f6 = f6 + f8;
                                                    f1 = f11 * f1;
                                                    f8 = f12 + f13;
                                                    f3 = f6 + f3;
                                                    r9 = sp + numDefineNeg728;
                                                    f1 = f1 + f15;
                                                    f6 = f8 + f9;
                                                    f3 = f3 + f16;
                                                    f1 = f1 + f7;
                                                    r11 = r9 >> numDefine2;
                                                    f6 = f6 + f17;
                                                    heapClassInst.heapFloat[fp + numDefineNeg182] = f3;
                                                    f1 = f1 + f18;
                                                    heapClassInst.heapFloat[r11 + 1] = f6;
                                                    heapClassInst.heapFloat[r11 + numDefine2] = f1;
                                                    heapClassInst.heap32[r11 + numDefine3] = 0;
                                                    r11 = heapClassInst.heap32[r1];
                                                    r11 = r11 >> numDefine2;
                                                    r11 = heapClassInst.heap32[r11 + numDefine4];
                                                    heapClassInst.heap32[g0] = r0;
                                                    functionTable.get(r11 >> numDefine2).accept(i7);
                                                    r12 = commonVariable.rg0 >> numDefine2;
                                                    r12 = heapClassInst.heap32[r12];
                                                    r12 = r12 >> numDefine2;
                                                    r12 = heapClassInst.heap32[r12 + numDefine2];
                                                    r13 = sp + numDefineNeg40;
                                                    r14 = r13 >> numDefine2;
                                                    heapClassInst.heap32[fp + numDefineNeg10] = 0;
                                                    heapClassInst.heap32[r14 + 1] = 0;
                                                    heapClassInst.heap32[r14 + numDefine2] = 0;
                                                    heapClassInst.heap32[r14 + numDefine3] = 0;
                                                    heapClassInst.heap32[g0] = commonVariable.rg0;
                                                    heapClassInst.heap32[g0 + 1] = r2;
                                                    heapClassInst.heap32[g0 + numDefine2] = r9;
                                                    heapClassInst.heap32[g0 + numDefine3] = r13;
                                                    functionTable.get(r12 >> numDefine2).accept(i7);
                                                    r2 = sp + numDefineNeg744;
                                                    r9 = r2 >> numDefine2;
                                                    heapClassInst.heapFloat[fp + numDefineNeg186] = f2;
                                                    heapClassInst.heapFloat[r9 + 1] = f5;
                                                    heapClassInst.heapFloat[r9 + numDefine2] = f11;
                                                    r11 = sp + numDefineNeg760;
                                                    heapClassInst.heap32[r9 + numDefine3] = 0;
                                                    r9 = r11 >> numDefine2;
                                                    heapClassInst.heapFloat[fp + numDefineNeg190] = f0;
                                                    heapClassInst.heapFloat[r9 + 1] = f4;
                                                    heapClassInst.heapFloat[r9 + numDefine2] = f10;
                                                    heapClassInst.heap32[r9 + numDefine3] = 0;
                                                    r9 = heapClassInst.heap32[r1];
                                                    r9 = r9 >> numDefine2;
                                                    r9 = heapClassInst.heap32[r9 + numDefine4];
                                                    f0 = heapClassInst.heapFloat[r10 + numDefine45];
                                                    f1 = heapClassInst.heapFloat[r10 + numDefine46];
                                                    heapClassInst.heap32[g0] = r0;
                                                    functionTable.get(r9 >> numDefine2).accept(i7);
                                                    r10 = commonVariable.rg0 >> numDefine2;
                                                    r10 = heapClassInst.heap32[r10];
                                                    r10 = r10 >> numDefine2;
                                                    r10 = heapClassInst.heap32[r10 + numDefine15];
                                                    r12 = sp + numDefineNeg24;
                                                    r13 = r12 >> numDefine2;
                                                    heapClassInst.heap32[fp + numDefineNeg6] = 0;
                                                    heapClassInst.heap32[r13 + 1] = 0;
                                                    heapClassInst.heap32[r13 + numDefine2] = 0;
                                                    heapClassInst.heap32[r13 + numDefine3] = 0;
                                                    heapClassInst.heap32[g0] = commonVariable.rg0;
                                                    heapClassInst.heap32[g0 + 1] = r8;
                                                    heapClassInst.heap32[g0 + numDefine2] = r2;
                                                    heapClassInst.heap32[g0 + numDefine3] = r11;
                                                    f2 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                                    heapClassInst.heapFloat[g0 + numDefine4] = f2;
                                                    heapClassInst.heapFloat[g0 + numDefine5] = f2;
                                                    heapClassInst.heapFloat[g0 + numDefine6] = f0;
                                                    heapClassInst.heapFloat[g0 + numDefine7] = f1;
                                                    heapClassInst.heap32[g0 + numDefine8] = r12;
                                                    heapClassInst.heap32[g0 + numDefine9] = 1;
                                                    heapClassInst.heap32[g0 + numDefine10] = (int) numDefine16192;
                                                    functionTable.get(r10 >> numDefine2).accept(i7);
                                                }
                                            } else {
                                                break repeat7;
                                            }
                                        }
                                    }
                                } else {
                                    if (r11 == numDefine3) {
                                        r2 = sp + numDefineNeg232;
                                        r9 = r2 >> numDefine2;
                                        heapClassInst.heap32[fp + numDefineNeg58] = (int) numDefine53216;
                                        heapClassInst.heap32[r9 + 1] = 0;
                                        heapClassInst.heap32[r9 + numDefine2] = 0;
                                        heapClassInst.heap32[r9 + numDefine3] = 0;
                                        heapClassInst.heap32[r9 + numDefine4] = 0;
                                        heapClassInst.heap32[r9 + numDefine5] = (int) numDefine53216;
                                        heapClassInst.heap32[r9 + numDefine6] = 0;
                                        heapClassInst.heap32[r9 + numDefine7] = 0;
                                        heapClassInst.heap32[r9 + numDefine8] = 0;
                                        heapClassInst.heap32[r9 + numDefine9] = 0;
                                        heapClassInst.heap32[r9 + numDefine10] = (int) numDefine53216;
                                        heapClassInst.heap32[r9 + numDefine11] = 0;
                                        heapClassInst.heap32[r9 + numDefine12] = 0;
                                        heapClassInst.heap32[r9 + numDefine13] = 0;
                                        heapClassInst.heap32[r9 + numDefine14] = 0;
                                        heapClassInst.heap32[r9 + numDefine15] = 0;
                                        r11 = heapClassInst.heap32[r10 + numDefine5];
                                        r11 = r11 >> numDefine2;
                                        f0 = heapClassInst.heapFloat[r10 + numDefine72];
                                        f1 = heapClassInst.heapFloat[r11 + 1];
                                        f2 = heapClassInst.heapFloat[r10 + numDefine73];
                                        f3 = heapClassInst.heapFloat[r11 + numDefine2];
                                        f4 = heapClassInst.heapFloat[r11 + numDefine5];
                                        f5 = heapClassInst.heapFloat[r11 + numDefine6];
                                        f1 = f1 * f0;
                                        f3 = f3 * f2;
                                        f6 = heapClassInst.heapFloat[r10 + numDefine74];
                                        f7 = heapClassInst.heapFloat[r11 + numDefine3];
                                        f8 = heapClassInst.heapFloat[r11 + numDefine9];
                                        f9 = heapClassInst.heapFloat[r11 + numDefine10];
                                        f10 = heapClassInst.heapFloat[r11 + numDefine7];
                                        f4 = f4 * f0;
                                        f5 = f5 * f2;
                                        f1 = f1 + f3;
                                        f3 = f7 * f6;
                                        f7 = heapClassInst.heapFloat[r11 + numDefine11];
                                        f0 = f8 * f0;
                                        f2 = f9 * f2;
                                        f4 = f4 + f5;
                                        f5 = f10 * f6;
                                        f1 = f1 + f3;
                                        f3 = heapClassInst.heapFloat[r11 + numDefine13];
                                        f8 = heapClassInst.heapFloat[r11 + numDefine15];
                                        f9 = heapClassInst.heapFloat[r11 + numDefine14];
                                        f4 = f4 + f5;
                                        f0 = f0 + f2;
                                        f2 = f7 * f6;
                                        f1 = f1 + f3;
                                        f0 = f0 + f2;
                                        f2 = f4 + f9;
                                        heapClassInst.heapFloat[r9 + numDefine12] = f1;
                                        f0 = f0 + f8;
                                        heapClassInst.heapFloat[r9 + numDefine13] = f2;
                                        heapClassInst.heapFloat[r9 + numDefine14] = f0;
                                        heapClassInst.heap32[r9 + numDefine15] = 0;
                                        r11 = heapClassInst.heap32[r1];
                                        r11 = r11 >> numDefine2;
                                        r11 = heapClassInst.heap32[r11 + numDefine4];
                                        heapClassInst.heap32[g0] = r0;
                                        functionTable.get(r11 >> numDefine2).accept(i7);
                                        r12 = commonVariable.rg0 >> numDefine2;
                                        r12 = heapClassInst.heap32[r12];
                                        r12 = r12 >> numDefine2;
                                        r12 = heapClassInst.heap32[r12 + numDefine14];
                                        heapClassInst.heap32[g0] = commonVariable.rg0;
                                        heapClassInst.heap32[g0 + 1] = r2;
                                        f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                        heapClassInst.heapFloat[g0 + numDefine2] = f0;
                                        functionTable.get(r12 >> numDefine2).accept(i7);
                                        r11 = heapClassInst.heap32[r10 + numDefine6];
                                        r11 = r11 >> numDefine2;
                                        f0 = heapClassInst.heapFloat[r10 + numDefine76];
                                        f1 = heapClassInst.heapFloat[r11 + 1];
                                        f2 = heapClassInst.heapFloat[r10 + numDefine77];
                                        f3 = heapClassInst.heapFloat[r11 + numDefine2];
                                        f4 = heapClassInst.heapFloat[r11 + numDefine5];
                                        f5 = heapClassInst.heapFloat[r11 + numDefine6];
                                        f1 = f1 * f0;
                                        f3 = f3 * f2;
                                        f6 = heapClassInst.heapFloat[r10 + numDefine78];
                                        f7 = heapClassInst.heapFloat[r11 + numDefine3];
                                        f8 = heapClassInst.heapFloat[r11 + numDefine9];
                                        f9 = heapClassInst.heapFloat[r11 + numDefine10];
                                        f10 = heapClassInst.heapFloat[r11 + numDefine7];
                                        f4 = f4 * f0;
                                        f5 = f5 * f2;
                                        f1 = f1 + f3;
                                        f3 = f7 * f6;
                                        f7 = heapClassInst.heapFloat[r11 + numDefine11];
                                        f0 = f8 * f0;
                                        f2 = f9 * f2;
                                        f4 = f4 + f5;
                                        f5 = f10 * f6;
                                        f1 = f1 + f3;
                                        f3 = heapClassInst.heapFloat[r11 + numDefine13];
                                        f8 = heapClassInst.heapFloat[r11 + numDefine15];
                                        f9 = heapClassInst.heapFloat[r11 + numDefine14];
                                        f4 = f4 + f5;
                                        f0 = f0 + f2;
                                        f2 = f7 * f6;
                                        f1 = f1 + f3;
                                        f0 = f0 + f2;
                                        f2 = f4 + f9;
                                        heapClassInst.heapFloat[r9 + numDefine12] = f1;
                                        f0 = f0 + f8;
                                        heapClassInst.heapFloat[r9 + numDefine13] = f2;
                                        heapClassInst.heapFloat[r9 + numDefine14] = f0;
                                        heapClassInst.heap32[r9 + numDefine15] = 0;
                                        if (!(r8 == 0)) {
                                            r8 = heapClassInst.heap32[r1];
                                            r8 = r8 >> numDefine2;
                                            r8 = heapClassInst.heap32[r8 + numDefine4];
                                            heapClassInst.heap32[g0] = r0;
                                            functionTable.get(r8 >> numDefine2).accept(i7);
                                            r9 = commonVariable.rg0 >> numDefine2;
                                            r9 = heapClassInst.heap32[r9];
                                            r9 = r9 >> numDefine2;
                                            r9 = heapClassInst.heap32[r9 + numDefine14];
                                            heapClassInst.heap32[g0] = commonVariable.rg0;
                                            heapClassInst.heap32[g0 + 1] = r2;
                                            f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                            heapClassInst.heapFloat[g0 + numDefine2] = f0;
                                            functionTable.get(r9 >> numDefine2).accept(i7);
                                        }
                                    } else {
                                        if (r11 == numDefine4) {
                                            r2 = heapClassInst.heap32[r10 + numDefine5];
                                            r2 = r2 >> numDefine2;
                                            f0 = heapClassInst.heapFloat[r2 + 1];
                                            f1 = heapClassInst.heapFloat[r10 + numDefine135];
                                            f2 = heapClassInst.heapFloat[r2 + numDefine2];
                                            f3 = heapClassInst.heapFloat[r10 + numDefine139];
                                            f4 = heapClassInst.heapFloat[r10 + numDefine136];
                                            f5 = heapClassInst.heapFloat[r10 + numDefine140];
                                            f6 = f1 * f0;
                                            f7 = f3 * f2;
                                            f8 = heapClassInst.heapFloat[r2 + numDefine3];
                                            f9 = heapClassInst.heapFloat[r10 + numDefine143];
                                            f10 = heapClassInst.heapFloat[r2 + numDefine9];
                                            f11 = heapClassInst.heapFloat[r10 + numDefine147];
                                            f12 = heapClassInst.heapFloat[r2 + numDefine5];
                                            f13 = heapClassInst.heapFloat[r10 + numDefine137];
                                            f14 = heapClassInst.heapFloat[r2 + numDefine10];
                                            f15 = heapClassInst.heapFloat[r10 + numDefine148];
                                            f16 = heapClassInst.heapFloat[r2 + numDefine6];
                                            f17 = heapClassInst.heapFloat[r10 + numDefine141];
                                            f18 = heapClassInst.heapFloat[r2 + numDefine11];
                                            f19 = heapClassInst.heapFloat[r10 + numDefine149];
                                            f20 = heapClassInst.heapFloat[r2 + numDefine7];
                                            f21 = heapClassInst.heapFloat[r10 + numDefine145];
                                            f22 = heapClassInst.heapFloat[r10 + numDefine144];
                                            f23 = f4 * f0;
                                            f24 = f5 * f2;
                                            f6 = f6 + f7;
                                            f7 = f9 * f8;
                                            f25 = heapClassInst.heapFloat[r2 + numDefine15];
                                            f26 = heapClassInst.heapFloat[r2 + numDefine14];
                                            f27 = heapClassInst.heapFloat[r2 + numDefine13];
                                            f28 = f13 * f0;
                                            f29 = f17 * f2;
                                            f23 = f23 + f24;
                                            f24 = f22 * f8;
                                            f6 = f6 + f7;
                                            r2 = r3 >> numDefine2;
                                            f7 = f28 + f29;
                                            f28 = f21 * f8;
                                            f23 = f23 + f24;
                                            heapClassInst.heapFloat[fp + numDefineNeg74] = f6;
                                            f6 = f1 * f12;
                                            f24 = f3 * f16;
                                            f7 = f7 + f28;
                                            heapClassInst.heapFloat[r2 + 1] = f23;
                                            heapClassInst.heapFloat[r2 + numDefine2] = f7;
                                            f7 = f4 * f12;
                                            f23 = f5 * f16;
                                            f6 = f6 + f24;
                                            f24 = f9 * f20;
                                            f28 = f13 * f12;
                                            f29 = f17 * f16;
                                            f7 = f7 + f23;
                                            f23 = f22 * f20;
                                            f6 = f6 + f24;
                                            heapClassInst.heap32[r2 + numDefine3] = 0;
                                            f24 = f28 + f29;
                                            f28 = f21 * f20;
                                            f7 = f7 + f23;
                                            heapClassInst.heapFloat[r2 + numDefine4] = f6;
                                            f1 = f1 * f10;
                                            f3 = f3 * f14;
                                            f6 = f24 + f28;
                                            heapClassInst.heapFloat[r2 + numDefine5] = f7;
                                            heapClassInst.heapFloat[r2 + numDefine6] = f6;
                                            f4 = f4 * f10;
                                            f5 = f5 * f14;
                                            f1 = f1 + f3;
                                            f3 = f9 * f18;
                                            f6 = f13 * f10;
                                            f7 = f17 * f14;
                                            f4 = f4 + f5;
                                            f5 = f22 * f18;
                                            f1 = f1 + f3;
                                            heapClassInst.heap32[r2 + numDefine7] = 0;
                                            f0 = f0 * f11;
                                            f2 = f2 * f15;
                                            f3 = f6 + f7;
                                            f6 = f21 * f18;
                                            f4 = f4 + f5;
                                            heapClassInst.heapFloat[r2 + numDefine8] = f1;
                                            f1 = f12 * f11;
                                            f5 = f16 * f15;
                                            f0 = f0 + f2;
                                            f2 = f8 * f19;
                                            f3 = f3 + f6;
                                            heapClassInst.heapFloat[r2 + numDefine9] = f4;
                                            f0 = f0 + f2;
                                            heapClassInst.heapFloat[r2 + numDefine10] = f3;
                                            f2 = f10 * f11;
                                            f3 = f14 * f15;
                                            f1 = f1 + f5;
                                            f4 = f20 * f19;
                                            f1 = f1 + f4;
                                            f2 = f2 + f3;
                                            f3 = f18 * f19;
                                            f0 = f0 + f27;
                                            heapClassInst.heap32[r2 + numDefine11] = 0;
                                            f2 = f2 + f3;
                                            f1 = f1 + f26;
                                            heapClassInst.heapFloat[r2 + numDefine12] = f0;
                                            f0 = f2 + f25;
                                            heapClassInst.heapFloat[r2 + numDefine13] = f1;
                                            heapClassInst.heapFloat[r2 + numDefine14] = f0;
                                            heapClassInst.heap32[r2 + numDefine15] = 0;
                                            if (!(r8 == 0)) {
                                                r11 = heapClassInst.heap32[r1];
                                                r11 = r11 >> numDefine2;
                                                r11 = heapClassInst.heap32[r11 + numDefine4];
                                                heapClassInst.heap32[g0] = r0;
                                                functionTable.get(r11 >> numDefine2).accept(i7);
                                                r12 = commonVariable.rg0 >> numDefine2;
                                                r12 = heapClassInst.heap32[r12];
                                                r12 = r12 >> numDefine2;
                                                r12 = heapClassInst.heap32[r12 + numDefine14];
                                                heapClassInst.heap32[g0] = commonVariable.rg0;
                                                heapClassInst.heap32[g0 + 1] = r3;
                                                f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                                heapClassInst.heapFloat[g0 + numDefine2] = f0;
                                                functionTable.get(r12 >> numDefine2).accept(i7);
                                            }
                                            r11 = heapClassInst.heap32[r10 + numDefine6];
                                            r11 = r11 >> numDefine2;
                                            f0 = heapClassInst.heapFloat[r11 + 1];
                                            f1 = heapClassInst.heapFloat[r10 + numDefine151];
                                            f2 = heapClassInst.heapFloat[r11 + numDefine2];
                                            f3 = heapClassInst.heapFloat[r10 + numDefine155];
                                            f4 = heapClassInst.heapFloat[r10 + numDefine152];
                                            f5 = heapClassInst.heapFloat[r10 + numDefine156];
                                            f6 = f1 * f0;
                                            f7 = f3 * f2;
                                            f8 = heapClassInst.heapFloat[r11 + numDefine3];
                                            f9 = heapClassInst.heapFloat[r10 + numDefine159];
                                            f10 = heapClassInst.heapFloat[r11 + numDefine9];
                                            f11 = heapClassInst.heapFloat[r10 + numDefine163];
                                            f12 = heapClassInst.heapFloat[r11 + numDefine5];
                                            f13 = heapClassInst.heapFloat[r10 + numDefine153];
                                            f14 = heapClassInst.heapFloat[r11 + numDefine10];
                                            f15 = heapClassInst.heapFloat[r10 + numDefine164];
                                            f16 = heapClassInst.heapFloat[r11 + numDefine6];
                                            f17 = heapClassInst.heapFloat[r10 + numDefine157];
                                            f18 = heapClassInst.heapFloat[r11 + numDefine11];
                                            f19 = heapClassInst.heapFloat[r10 + numDefine165];
                                            f20 = heapClassInst.heapFloat[r11 + numDefine7];
                                            f21 = heapClassInst.heapFloat[r10 + numDefine161];
                                            f22 = heapClassInst.heapFloat[r10 + numDefine160];
                                            f23 = f4 * f0;
                                            f24 = f5 * f2;
                                            f6 = f6 + f7;
                                            f7 = f9 * f8;
                                            f25 = heapClassInst.heapFloat[r11 + numDefine15];
                                            f26 = heapClassInst.heapFloat[r11 + numDefine14];
                                            f27 = heapClassInst.heapFloat[r11 + numDefine13];
                                            f28 = f13 * f0;
                                            f29 = f17 * f2;
                                            f23 = f23 + f24;
                                            f24 = f22 * f8;
                                            f6 = f6 + f7;
                                            f7 = f28 + f29;
                                            f28 = f21 * f8;
                                            f23 = f23 + f24;
                                            heapClassInst.heapFloat[fp + numDefineNeg74] = f6;
                                            f6 = f1 * f12;
                                            f24 = f3 * f16;
                                            f7 = f7 + f28;
                                            heapClassInst.heapFloat[r2 + 1] = f23;
                                            heapClassInst.heapFloat[r2 + numDefine2] = f7;
                                            f7 = f4 * f12;
                                            f23 = f5 * f16;
                                            f6 = f6 + f24;
                                            f24 = f9 * f20;
                                            f28 = f13 * f12;
                                            f29 = f17 * f16;
                                            f7 = f7 + f23;
                                            f23 = f22 * f20;
                                            f6 = f6 + f24;
                                            heapClassInst.heap32[r2 + numDefine3] = 0;
                                            f24 = f28 + f29;
                                            f28 = f21 * f20;
                                            f7 = f7 + f23;
                                            heapClassInst.heapFloat[r2 + numDefine4] = f6;
                                            f1 = f1 * f10;
                                            f3 = f3 * f14;
                                            f6 = f24 + f28;
                                            heapClassInst.heapFloat[r2 + numDefine5] = f7;
                                            heapClassInst.heapFloat[r2 + numDefine6] = f6;
                                            f4 = f4 * f10;
                                            f5 = f5 * f14;
                                            f1 = f1 + f3;
                                            f3 = f9 * f18;
                                            f6 = f13 * f10;
                                            f7 = f17 * f14;
                                            f4 = f4 + f5;
                                            f5 = f22 * f18;
                                            f1 = f1 + f3;
                                            heapClassInst.heap32[r2 + numDefine7] = 0;
                                            f0 = f0 * f11;
                                            f2 = f2 * f15;
                                            f3 = f6 + f7;
                                            f6 = f21 * f18;
                                            f4 = f4 + f5;
                                            heapClassInst.heapFloat[r2 + numDefine8] = f1;
                                            f1 = f12 * f11;
                                            f5 = f16 * f15;
                                            f0 = f0 + f2;
                                            f2 = f8 * f19;
                                            f3 = f3 + f6;
                                            heapClassInst.heapFloat[r2 + numDefine9] = f4;
                                            f0 = f0 + f2;
                                            heapClassInst.heapFloat[r2 + numDefine10] = f3;
                                            f2 = f10 * f11;
                                            f3 = f14 * f15;
                                            f1 = f1 + f5;
                                            f4 = f20 * f19;
                                            f1 = f1 + f4;
                                            f2 = f2 + f3;
                                            f3 = f18 * f19;
                                            f0 = f0 + f27;
                                            heapClassInst.heap32[r2 + numDefine11] = 0;
                                            f2 = f2 + f3;
                                            f1 = f1 + f26;
                                            heapClassInst.heapFloat[r2 + numDefine12] = f0;
                                            f0 = f2 + f25;
                                            heapClassInst.heapFloat[r2 + numDefine13] = f1;
                                            heapClassInst.heapFloat[r2 + numDefine14] = f0;
                                            heapClassInst.heap32[r2 + numDefine15] = 0;
                                            if (!(r8 == 0)) {
                                                r8 = heapClassInst.heap32[r1];
                                                r8 = r8 >> numDefine2;
                                                r8 = heapClassInst.heap32[r8 + numDefine4];
                                                heapClassInst.heap32[g0] = r0;
                                                functionTable.get(r8 >> numDefine2).accept(i7);
                                                r11 = commonVariable.rg0 >> numDefine2;
                                                r11 = heapClassInst.heap32[r11];
                                                r11 = r11 >> numDefine2;
                                                r11 = heapClassInst.heap32[r11 + numDefine14];
                                                heapClassInst.heap32[g0] = commonVariable.rg0;
                                                heapClassInst.heap32[g0 + 1] = r3;
                                                f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                                heapClassInst.heapFloat[g0 + numDefine2] = f0;
                                                functionTable.get(r11 >> numDefine2).accept(i7);
                                            }
                                            f0 = heapClassInst.heapFloat[r10 + numDefine172];
                                            f1 = heapClassInst.heapFloat[r10 + numDefine173];
                                            if (!(f0 == f1)) {
                                                if (!(r9 == 0)) {
                                                    r8 = sp + numDefineNeg312;
                                                    r9 = r8 >> numDefine2;
                                                    heapClassInst.heap32[fp + numDefineNeg78] = heapClassInst.heap32[r2 + numDefine2];
                                                    heapClassInst.heap32[r9 + 1] = heapClassInst.heap32[r2 + numDefine6];
                                                    heapClassInst.heap32[r9 + numDefine2] = heapClassInst.heap32[r2 + numDefine10];
                                                    r10 = sp + numDefineNeg328;
                                                    heapClassInst.heap32[r9 + numDefine3] = 0;
                                                    r9 = r10 >> numDefine2;
                                                    heapClassInst.heap32[fp + numDefineNeg82] = heapClassInst.heap32[fp + numDefineNeg74];
                                                    heapClassInst.heap32[r9 + 1] = heapClassInst.heap32[r2 + numDefine4];
                                                    heapClassInst.heap32[r9 + numDefine2] = heapClassInst.heap32[r2 + numDefine8];
                                                    heapClassInst.heap32[r9 + numDefine3] = 0;
                                                    r2 = heapClassInst.heap32[r1];
                                                    r2 = r2 >> numDefine2;
                                                    r2 = heapClassInst.heap32[r2 + numDefine4];
                                                    heapClassInst.heap32[g0] = r0;
                                                    functionTable.get(r2 >> numDefine2).accept(i7);
                                                    r9 = commonVariable.rg0 >> numDefine2;
                                                    r9 = heapClassInst.heap32[r9];
                                                    r9 = r9 >> numDefine2;
                                                    r9 = heapClassInst.heap32[r9 + numDefine15];
                                                    r11 = sp + numDefineNeg168;
                                                    r12 = r11 >> numDefine2;
                                                    heapClassInst.heap32[fp + numDefineNeg42] = 0;
                                                    heapClassInst.heap32[r12 + 1] = 0;
                                                    heapClassInst.heap32[r12 + numDefine2] = 0;
                                                    heapClassInst.heap32[r12 + numDefine3] = 0;
                                                    f2 = (float) numDefineFloat265;

                                                    r12 = f0 <= f1 ? 1 : 0;
                                                    f3 = heapClassInst.heapFloat[fp + numDefineNeg192];
                                                    f3 = f0 > f1 ? f3 : f0;
                                                    f0 = f0 > f1 ? f2 : f1;
                                                    r12 = r12 & 1;
                                                    heapClassInst.heap32[g0] = commonVariable.rg0;
                                                    heapClassInst.heap32[g0 + 1] = r5;
                                                    heapClassInst.heap32[g0 + numDefine2] = r8;
                                                    heapClassInst.heap32[g0 + numDefine3] = r10;
                                                    f1 = heapClassInst.heapFloat[fp + numDefineNeg191];
                                                    heapClassInst.heapFloat[g0 + numDefine4] = f1;
                                                    heapClassInst.heapFloat[g0 + numDefine5] = f1;
                                                    heapClassInst.heapFloat[g0 + numDefine6] = f3;
                                                    heapClassInst.heapFloat[g0 + numDefine7] = f0;
                                                    heapClassInst.heap32[g0 + numDefine8] = r11;
                                                    heapClassInst.heap32[g0 + numDefine9] = r12;
                                                    heapClassInst.heap32[g0 + numDefine10] = (int) numDefine16192;
                                                    functionTable.get(r9 >> numDefine2).accept(i7);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        } while (false);
                        r2 = (r7 + -1) | 0;
                        if (r7 != 0) {
                            continue repeat5;
                        } else {
                            break repeat5;
                        }
                    }
                }
            }
        }
        r2 = heapClassInst.heap32[r1];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine4];
        heapClassInst.heap32[g0] = r0;
        functionTable.get(r2 >> numDefine2).accept(i7);
        r2 = commonVariable.rg0;
        repeat74:
        do {
            if (!(r2 == 0)) {
                r2 = heapClassInst.heap32[r1];
                r2 = r2 >> numDefine2;
                r2 = heapClassInst.heap32[r2 + numDefine4];
                heapClassInst.heap32[g0] = r0;
                functionTable.get(r2 >> numDefine2).accept(i7);
                r3 = commonVariable.rg0 >> numDefine2;
                r3 = heapClassInst.heap32[r3];
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3 + numDefine12];
                heapClassInst.heap32[g0] = commonVariable.rg0;
                functionTable.get(r3 >> numDefine2).accept(i7);
                r2 = commonVariable.rg0 & numDefine3;
                if (!(r2 == 0)) {
                    r2 = heapClassInst.heap32[r1];
                    r2 = r2 >> numDefine2;
                    r2 = heapClassInst.heap32[r2 + numDefine4];
                    heapClassInst.heap32[g0] = r0;
                    functionTable.get(r2 >> numDefine2).accept(i7);
                    r2 = commonVariable.rg0;
                    if (!(r2 == 0)) {
                        r2 = heapClassInst.heap32[r1];
                        r2 = r2 >> numDefine2;
                        r2 = heapClassInst.heap32[r2 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        functionTable.get(r2 >> numDefine2).accept(i7);
                        r2 = commonVariable.rg0 >> numDefine2;
                        r2 = heapClassInst.heap32[r2];
                        r2 = r2 >> numDefine2;
                        r2 = heapClassInst.heap32[r2 + numDefine12];
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        functionTable.get(r2 >> numDefine2).accept(i7);
                        r0 = commonVariable.rg0;
                        if (!(r0 == 0)) {
                            r0 = heapClassInst.heap32[r1 + numDefine63];
                            if (!(r0 < 1)) {
                                r0 = 0;
                                repeat80:
                                while (true) {
                                    r2 = heapClassInst.heap32[r1 + numDefine65];
                                    r3 = r0 << numDefine2;
                                    r2 = (r2 + r3) | 0;
                                    r2 = r2 >> numDefine2;
                                    r2 = heapClassInst.heap32[r2];
                                    r3 = r2 >> numDefine2;
                                    r3 = heapClassInst.heap32[r3];
                                    r3 = r3 >> numDefine2;
                                    r3 = heapClassInst.heap32[r3 + numDefine3];
                                    r4 = heapClassInst.heap32[r1 + numDefine21];
                                    heapClassInst.heap32[g0] = r2;
                                    heapClassInst.heap32[g0 + 1] = r4;
                                    r0 = (r0 + 1) | 0;
                                    functionTable.get(r3 >> numDefine2).accept(i7);
                                    r2 = heapClassInst.heap32[r1 + numDefine63];
                                    if (r2 > r0) {
                                        continue repeat80;
                                    } else {
                                        break repeat74;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        } while (false);
        r0 = zn15CProfileManager11CurrentNodeE;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        r2 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + numDefine4];
        r3 = (r3 + -1) | 0;
        heapClassInst.heap32[r2 + numDefine4] = r3;
        repeat83:
        do {
            if (!(r3 != 0)) {
                r3 = heapClassInst.heap32[r2 + 1];
                if (r3 != 0) {
                    r1 = sp + numDefineNeg8;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = 0;
                    r3 = zl13gProfileClock2E0;
                    getTimeOfDay(i7);
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r1 = r1 >> numDefine2;
                    r4 = heapClassInst.heap32[fp + numDefineNeg2];
                    r5 = heapClassInst.heap32[r3];
                    r4 = (r4 - r5) | 0;
                    r1 = heapClassInst.heap32[r1 + 1];
                    r3 = heapClassInst.heap32[r3 + 1];
                    r1 = (r1 - r3) | 0;
                    r3 = (int) ((r4 * numDefineN6) | 0);
                    r1 = (r1 + r3) | 0;
                    r3 = heapClassInst.heap32[r2 + numDefine3];
                    r1 = (r1 - r3) | 0;
                    f0 = uint(r1);
                    f1 = numDefine1000;
                    f2 = heapClassInst.heapFloat[r2 + numDefine2];
                    f0 = f0 / f1;
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r2 + numDefine2] = f0;
                    r1 = heapClassInst.heap32[r2 + numDefine4];
                    if (r1 != 0) {
                        break repeat83;
                    } else {
                        r1 = heapClassInst.heap32[r0];
                    }
                }
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1 + numDefine5];
                heapClassInst.heap32[r0] = r1;
            }
        } while (false);
        
    }

    public static void zn23btDiscreteDynamicsWorld18saveKinematicStateEf(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg40;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + numDefine2];
        if (!(r1 < 1)) {
            f0 = heapClassInst.heapFloat[fp + 1];
            f1 = 1;
            f1 = f1 / f0;
            r1 = 0;
            repeat3:
            while (true) {
                r2 = heapClassInst.heap32[r0 + numDefine4];
                r3 = r1 << numDefine2;
                r2 = (r2 + r3) | 0;
                r2 = r2 >> numDefine2;
                r2 = heapClassInst.heap32[r2];
                r3 = heapClassInst.heapU8[r2 + numDefine232];
                r3 = r3 & numDefine2;
                if (!(r3 == 0)) {
                    if (!(r2 == 0)) {
                        r3 = r2 >> numDefine2;
                        r4 = heapClassInst.heap32[r3 + numDefine54];
                        if (!(r4 == numDefine2)) {
                            r4 = heapClassInst.heapU8[r2 + numDefine204];
                            r4 = r4 & numDefine2;
                            if (!(r4 == 0)) {
                                f2 = 0;
                                if (!(f0 == f2)) {
                                    r4 = heapClassInst.heap32[r3 + numDefine118];
                                    if (!(r4 == 0)) {
                                        r5 = r4 >> numDefine2;
                                        r5 = heapClassInst.heap32[r5];
                                        r5 = r5 >> numDefine2;
                                        r5 = heapClassInst.heap32[r5 + numDefine2];
                                        r6 = (r2 + numDefine4) | 0;
                                        heapClassInst.heap32[g0] = r4;
                                        heapClassInst.heap32[g0 + 1] = r6;
                                        functionTable.get(r5 >> numDefine2).accept(i7);
                                    }
                                    f2 = heapClassInst.heapFloat[r3 + numDefine13];
                                    f3 = heapClassInst.heapFloat[r3 + numDefine29];
                                    f2 = f2 - f3;
                                    f3 = heapClassInst.heapFloat[r3 + numDefine15];
                                    f4 = heapClassInst.heapFloat[r3 + numDefine31];
                                    f5 = heapClassInst.heapFloat[r3 + numDefine14];
                                    f6 = heapClassInst.heapFloat[r3 + numDefine30];
                                    f5 = f5 - f6;
                                    f2 = f2 * f1;
                                    f3 = f3 - f4;
                                    f4 = f5 * f1;
                                    heapClassInst.heapFloat[r3 + numDefine76] = f2;
                                    f2 = f3 * f1;
                                    heapClassInst.heapFloat[r3 + numDefine77] = f4;
                                    heapClassInst.heapFloat[r3 + numDefine78] = f2;
                                    heapClassInst.heap32[r3 + numDefine79] = 0;
                                    r4 = sp + numDefineNeg16;
                                    r5 = (r2 + numDefine68) | 0;
                                    r2 = (r2 + numDefine4) | 0;
                                    r6 = sp + numDefineNeg20;
                                    heapClassInst.heap32[g0] = r5;
                                    heapClassInst.heap32[g0 + 1] = r2;
                                    heapClassInst.heap32[g0 + numDefine2] = r4;
                                    heapClassInst.heap32[g0 + numDefine3] = r6;
                                    zn15btTransformUtil22calculateDiffAxisAngleERK11btTransformS2R9btVector3Rf(i7);
                                    r2 = r4 >> numDefine2;
                                    f2 = heapClassInst.heapFloat[fp + numDefineNeg5];
                                    f3 = heapClassInst.heapFloat[fp + numDefineNeg4];
                                    f3 = f3 * f2;
                                    f4 = heapClassInst.heapFloat[r2 + numDefine2];
                                    f5 = heapClassInst.heapFloat[r2 + 1];
                                    f5 = f5 * f2;
                                    f3 = f3 * f1;
                                    f2 = f4 * f2;
                                    f4 = f5 * f1;
                                    heapClassInst.heapFloat[r3 + numDefine80] = f3;
                                    f2 = f2 * f1;
                                    heapClassInst.heapFloat[r3 + numDefine81] = f4;
                                    heapClassInst.heapFloat[r3 + numDefine82] = f2;
                                    heapClassInst.heap32[r3 + numDefine83] = 0;
                                    heapClassInst.heap32[r3 + numDefine33] = heapClassInst.heap32[r3 + numDefine76];
                                    heapClassInst.heap32[r3 + numDefine34] = heapClassInst.heap32[r3 + numDefine77];
                                    heapClassInst.heap32[r3 + numDefine35] = heapClassInst.heap32[r3 + numDefine78];
                                    heapClassInst.heap32[r3 + numDefine36] = heapClassInst.heap32[r3 + numDefine79];
                                    heapClassInst.heapFloat[r3 + numDefine37] = f3;
                                    heapClassInst.heapFloat[r3 + numDefine38] = f4;
                                    heapClassInst.heapFloat[r3 + numDefine39] = f2;
                                    heapClassInst.heap32[r3 + numDefine40] = 0;
                                    heapClassInst.heap32[r3 + numDefine17] = heapClassInst.heap32[r3 + 1];
                                    heapClassInst.heap32[r3 + numDefine18] = heapClassInst.heap32[r3 + numDefine2];
                                    heapClassInst.heap32[r3 + numDefine19] = heapClassInst.heap32[r3 + numDefine3];
                                    heapClassInst.heap32[r3 + numDefine20] = heapClassInst.heap32[r3 + numDefine4];
                                    heapClassInst.heap32[r3 + numDefine21] = heapClassInst.heap32[r3 + numDefine5];
                                    heapClassInst.heap32[r3 + numDefine22] = heapClassInst.heap32[r3 + numDefine6];
                                    heapClassInst.heap32[r3 + numDefine23] = heapClassInst.heap32[r3 + numDefine7];
                                    heapClassInst.heap32[r3 + numDefine24] = heapClassInst.heap32[r3 + numDefine8];
                                    heapClassInst.heap32[r3 + numDefine25] = heapClassInst.heap32[r3 + numDefine9];
                                    heapClassInst.heap32[r3 + numDefine26] = heapClassInst.heap32[r3 + numDefine10];
                                    heapClassInst.heap32[r3 + numDefine27] = heapClassInst.heap32[r3 + numDefine11];
                                    heapClassInst.heap32[r3 + numDefine28] = heapClassInst.heap32[r3 + numDefine12];
                                    heapClassInst.heap32[r3 + numDefine29] = heapClassInst.heap32[r3 + numDefine13];
                                    heapClassInst.heap32[r3 + numDefine30] = heapClassInst.heap32[r3 + numDefine14];
                                    heapClassInst.heap32[r3 + numDefine31] = heapClassInst.heap32[r3 + numDefine15];
                                    heapClassInst.heap32[r3 + numDefine32] = heapClassInst.heap32[r3 + numDefine16];
                                }
                            }
                        }
                    }
                }
                r1 = (r1 + 1) | 0;
                r2 = heapClassInst.heap32[r0 + numDefine2];
                if (r2 > r1) {
                    continue repeat3;
                } else {
                    break repeat3;
                }
            }
        }
        
    }

    public static void zn15btDynamicsWorldD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv15btDynamicsWorld;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zn16btCollisionWorldD2Ev(i7);
        
    }

    public static void zn15btDynamicsWorldD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv15btDynamicsWorld;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zn16btCollisionWorldD2Ev(i7);
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn23btDiscreteDynamicsWorldD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv23btDiscreteDynamicsWorld;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = heapClassInst.heapU8[r0 + numDefine244];
        if (!(r1 == 0)) {
            r1 = heapClassInst.heap32[r2 + numDefine45];
            r3 = r1 >> numDefine2;
            r3 = heapClassInst.heap32[r3];
            r3 = r3 >> numDefine2;
            r3 = heapClassInst.heap32[r3];
            heapClassInst.heap32[g0] = r1;
            functionTable.get(r3 >> numDefine2).accept(i7);
            r1 = heapClassInst.heap32[r2 + numDefine45];
            if (!(r1 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
        }
        r1 = heapClassInst.heapU8[r0 + numDefine245];
        if (!(r1 == 0)) {
            r1 = heapClassInst.heap32[r2 + numDefine44];
            r3 = r1 >> numDefine2;
            r3 = heapClassInst.heap32[r3];
            r3 = r3 >> numDefine2;
            r3 = heapClassInst.heap32[r3];
            heapClassInst.heap32[g0] = r1;
            functionTable.get(r3 >> numDefine2).accept(i7);
            r1 = heapClassInst.heap32[r2 + numDefine44];
            if (!(r1 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
        }
        r1 = heapClassInst.heap32[r2 + numDefine65];
        if (!(r1 == 0)) {
            r3 = heapClassInst.heapU8[r0 + numDefine264];
            if (!(r3 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine65] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine264] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine65] = 0;
        heapClassInst.heap32[r2 + numDefine63] = 0;
        heapClassInst.heap32[r2 + numDefine64] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine54];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine220];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine54] = 0;
        }
        heapClassInst.heap8[r0 + numDefine220] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine54] = 0;
        heapClassInst.heap32[r2 + numDefine52] = 0;
        heapClassInst.heap32[r2 + numDefine53] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine49];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine200];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine49] = 0;
        }
        heapClassInst.heap8[r0 + numDefine200] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine49] = 0;
        r1 = ztv15btDynamicsWorld;
        heapClassInst.heap32[r2 + numDefine47] = 0;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2 + numDefine48] = 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zn16btCollisionWorldD2Ev(i7);
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn23btDiscreteDynamicsWorldD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        heapClassInst.heap32[g0] = r0;
        zn23btDiscreteDynamicsWorldD2Ev(i7);
        
    }

    static void zn23btDiscreteDynamicsWorldD2Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv23btDiscreteDynamicsWorld;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = heapClassInst.heapU8[r0 + numDefine244];
        if (!(r1 == 0)) {
            r1 = heapClassInst.heap32[r2 + numDefine45];
            r3 = r1 >> numDefine2;
            r3 = heapClassInst.heap32[r3];
            r3 = r3 >> numDefine2;
            r3 = heapClassInst.heap32[r3];
            heapClassInst.heap32[g0] = r1;
            functionTable.get(r3 >> numDefine2).accept(i7);
            r1 = heapClassInst.heap32[r2 + numDefine45];
            if (!(r1 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
        }
        r1 = heapClassInst.heapU8[r0 + numDefine245];
        if (!(r1 == 0)) {
            r1 = heapClassInst.heap32[r2 + numDefine44];
            r3 = r1 >> numDefine2;
            r3 = heapClassInst.heap32[r3];
            r3 = r3 >> numDefine2;
            r3 = heapClassInst.heap32[r3];
            heapClassInst.heap32[g0] = r1;
            functionTable.get(r3 >> numDefine2).accept(i7);
            r1 = heapClassInst.heap32[r2 + numDefine44];
            if (!(r1 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
        }
        r1 = heapClassInst.heap32[r2 + numDefine65];
        if (!(r1 == 0)) {
            r3 = heapClassInst.heapU8[r0 + numDefine264];
            if (!(r3 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine65] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine264] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine65] = 0;
        heapClassInst.heap32[r2 + numDefine63] = 0;
        heapClassInst.heap32[r2 + numDefine64] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine54];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine220];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine54] = 0;
        }
        heapClassInst.heap8[r0 + numDefine220] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine54] = 0;
        heapClassInst.heap32[r2 + numDefine52] = 0;
        heapClassInst.heap32[r2 + numDefine53] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine49];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine200];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine49] = 0;
        }
        heapClassInst.heap8[r0 + numDefine200] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine49] = 0;
        r1 = ztv15btDynamicsWorld;
        heapClassInst.heap32[r2 + numDefine47] = 0;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2 + numDefine48] = 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zn16btCollisionWorldD2Ev(i7);
        return;
    }

    static void zn11btRigidBody18proceedToTransformERK11btTransform(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        int r19 = 0;
        int r20 = 0;
        int r21 = 0;
        int r22 = 0;
        int r23 = 0;
        int r24 = 0;
        int r25 = 0;
        int label = 0;
        i7 = sp + numDefineNeg48;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heapU8[r0 + numDefine204];
        r2 = r2 & numDefine3;
        if (r2 == 0) {
            r2 = r0 >> numDefine2;
            r24 = r1 >> numDefine2;
            heapClassInst.heap32[r2 + numDefine17] = heapClassInst.heap32[r24];
            heapClassInst.heap32[r2 + numDefine18] = heapClassInst.heap32[r24 + 1];
            heapClassInst.heap32[r2 + numDefine19] = heapClassInst.heap32[r24 + numDefine2];
            heapClassInst.heap32[r2 + numDefine20] = heapClassInst.heap32[r24 + numDefine3];
            heapClassInst.heap32[r2 + numDefine21] = heapClassInst.heap32[r24 + numDefine4];
            heapClassInst.heap32[r2 + numDefine22] = heapClassInst.heap32[r24 + numDefine5];
            heapClassInst.heap32[r2 + numDefine23] = heapClassInst.heap32[r24 + numDefine6];
            heapClassInst.heap32[r2 + numDefine24] = heapClassInst.heap32[r24 + numDefine7];
            heapClassInst.heap32[r2 + numDefine25] = heapClassInst.heap32[r24 + numDefine8];
            heapClassInst.heap32[r2 + numDefine26] = heapClassInst.heap32[r24 + numDefine9];
            heapClassInst.heap32[r2 + numDefine27] = heapClassInst.heap32[r24 + numDefine10];
            heapClassInst.heap32[r2 + numDefine28] = heapClassInst.heap32[r24 + numDefine11];
            heapClassInst.heap32[r2 + numDefine29] = heapClassInst.heap32[r24 + numDefine12];
            heapClassInst.heap32[r2 + numDefine30] = heapClassInst.heap32[r24 + numDefine13];
            r15 = (r1 + numDefine4) | 0;
            r16 = (r1 + numDefine8) | 0;
            r17 = (r1 + numDefine12) | 0;
            r18 = (r1 + numDefine16) | 0;
            r19 = (r1 + numDefine20) | 0;
            r20 = (r1 + numDefine24) | 0;
            r21 = (r1 + numDefine28) | 0;
            r22 = (r1 + numDefine32) | 0;
            r23 = (r1 + numDefine36) | 0;
            r3 = (r1 + numDefine40) | 0;
            heapClassInst.heap32[fp + numDefineNeg10] = r3;
            r3 = (r1 + numDefine44) | 0;
            heapClassInst.heap32[fp + numDefineNeg4] = r3;
            r3 = (r1 + numDefine48) | 0;
            heapClassInst.heap32[fp + numDefineNeg7] = r3;
            r3 = (r1 + numDefine52) | 0;
            heapClassInst.heap32[fp + numDefineNeg6] = r3;
            r3 = (r1 + numDefine56) | 0;
            heapClassInst.heap32[fp + numDefineNeg9] = r3;
            r3 = (r1 + numDefine60) | 0;
            heapClassInst.heap32[fp + numDefineNeg8] = r3;
            r3 = (r0 + numDefine4) | 0;
            r4 = (r0 + numDefine8) | 0;
            r5 = (r0 + numDefine12) | 0;
            r6 = (r0 + numDefine16) | 0;
            r7 = (r0 + numDefine20) | 0;
            r8 = (r0 + numDefine24) | 0;
            r9 = (r0 + numDefine28) | 0;
            r10 = (r0 + numDefine32) | 0;
            r11 = (r0 + numDefine36) | 0;
            r12 = (r0 + numDefine40) | 0;
            r13 = (r0 + numDefine44) | 0;
            r14 = (r0 + numDefine48) | 0;
            r25 = (r0 + numDefine52) | 0;
            heapClassInst.heap32[fp + numDefineNeg5] = r25;
            r25 = (r0 + numDefine56) | 0;
            heapClassInst.heap32[fp + numDefineNeg3] = r25;
            r25 = (r0 + numDefine60) | 0;
            heapClassInst.heap32[fp + numDefineNeg2] = r25;
            r25 = (r0 + numDefine64) | 0;
            heapClassInst.heap32[fp + -1] = r25;
            heapClassInst.heap32[r2 + numDefine31] = heapClassInst.heap32[r24 + numDefine14];
            heapClassInst.heap32[r2 + numDefine32] = heapClassInst.heap32[r24 + numDefine15];
        } else {
            r2 = r0 >> numDefine2;
            heapClassInst.heap32[r2 + numDefine17] = heapClassInst.heap32[r2 + 1];
            heapClassInst.heap32[r2 + numDefine18] = heapClassInst.heap32[r2 + numDefine2];
            heapClassInst.heap32[r2 + numDefine19] = heapClassInst.heap32[r2 + numDefine3];
            heapClassInst.heap32[r2 + numDefine20] = heapClassInst.heap32[r2 + numDefine4];
            heapClassInst.heap32[r2 + numDefine21] = heapClassInst.heap32[r2 + numDefine5];
            heapClassInst.heap32[r2 + numDefine22] = heapClassInst.heap32[r2 + numDefine6];
            heapClassInst.heap32[r2 + numDefine23] = heapClassInst.heap32[r2 + numDefine7];
            heapClassInst.heap32[r2 + numDefine24] = heapClassInst.heap32[r2 + numDefine8];
            heapClassInst.heap32[r2 + numDefine25] = heapClassInst.heap32[r2 + numDefine9];
            heapClassInst.heap32[r2 + numDefine26] = heapClassInst.heap32[r2 + numDefine10];
            heapClassInst.heap32[r2 + numDefine27] = heapClassInst.heap32[r2 + numDefine11];
            heapClassInst.heap32[r2 + numDefine28] = heapClassInst.heap32[r2 + numDefine12];
            heapClassInst.heap32[r2 + numDefine29] = heapClassInst.heap32[r2 + numDefine13];
            heapClassInst.heap32[r2 + numDefine30] = heapClassInst.heap32[r2 + numDefine14];
            r3 = (r0 + numDefine4) | 0;
            r4 = (r0 + numDefine8) | 0;
            r5 = (r0 + numDefine12) | 0;
            r6 = (r0 + numDefine16) | 0;
            r7 = (r0 + numDefine20) | 0;
            r8 = (r0 + numDefine24) | 0;
            r9 = (r0 + numDefine28) | 0;
            r10 = (r0 + numDefine32) | 0;
            r11 = (r0 + numDefine36) | 0;
            r12 = (r0 + numDefine40) | 0;
            r13 = (r0 + numDefine44) | 0;
            r14 = (r0 + numDefine48) | 0;
            r15 = (r0 + numDefine52) | 0;
            heapClassInst.heap32[fp + numDefineNeg5] = r15;
            r15 = (r0 + numDefine56) | 0;
            heapClassInst.heap32[fp + numDefineNeg3] = r15;
            r15 = (r0 + numDefine60) | 0;
            heapClassInst.heap32[fp + numDefineNeg2] = r15;
            r15 = (r0 + numDefine64) | 0;
            heapClassInst.heap32[fp + -1] = r15;
            r15 = (r1 + numDefine4) | 0;
            r16 = (r1 + numDefine8) | 0;
            r17 = (r1 + numDefine12) | 0;
            r18 = (r1 + numDefine16) | 0;
            r19 = (r1 + numDefine20) | 0;
            r20 = (r1 + numDefine24) | 0;
            r21 = (r1 + numDefine28) | 0;
            r22 = (r1 + numDefine32) | 0;
            r23 = (r1 + numDefine36) | 0;
            r24 = (r1 + numDefine40) | 0;
            heapClassInst.heap32[fp + numDefineNeg10] = r24;
            r24 = (r1 + numDefine44) | 0;
            heapClassInst.heap32[fp + numDefineNeg4] = r24;
            r24 = (r1 + numDefine48) | 0;
            heapClassInst.heap32[fp + numDefineNeg7] = r24;
            r24 = (r1 + numDefine52) | 0;
            heapClassInst.heap32[fp + numDefineNeg6] = r24;
            r24 = (r1 + numDefine56) | 0;
            heapClassInst.heap32[fp + numDefineNeg9] = r24;
            r24 = (r1 + numDefine60) | 0;
            heapClassInst.heap32[fp + numDefineNeg8] = r24;
            heapClassInst.heap32[r2 + numDefine31] = heapClassInst.heap32[r2 + numDefine15];
            heapClassInst.heap32[r2 + numDefine32] = heapClassInst.heap32[r2 + numDefine16];
        }
        r2 = r0 >> numDefine2;
        heapClassInst.heap32[r2 + numDefine33] = heapClassInst.heap32[r2 + numDefine76];
        heapClassInst.heap32[r2 + numDefine34] = heapClassInst.heap32[r2 + numDefine77];
        heapClassInst.heap32[r2 + numDefine35] = heapClassInst.heap32[r2 + numDefine78];
        heapClassInst.heap32[r2 + numDefine36] = heapClassInst.heap32[r2 + numDefine79];
        heapClassInst.heap32[r2 + numDefine37] = heapClassInst.heap32[r2 + numDefine80];
        heapClassInst.heap32[r2 + numDefine38] = heapClassInst.heap32[r2 + numDefine81];
        heapClassInst.heap32[r2 + numDefine39] = heapClassInst.heap32[r2 + numDefine82];
        r3 = r3 >> numDefine2;
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r2 + numDefine40] = heapClassInst.heap32[r2 + numDefine83];
        r2 = r4 >> numDefine2;
        r4 = r15 >> numDefine2;
        heapClassInst.heap32[r3] = heapClassInst.heap32[r1];
        r1 = r5 >> numDefine2;
        r3 = r16 >> numDefine2;
        heapClassInst.heap32[r2] = heapClassInst.heap32[r4];
        r2 = r6 >> numDefine2;
        r4 = r17 >> numDefine2;
        heapClassInst.heap32[r1] = heapClassInst.heap32[r3];
        r1 = r7 >> numDefine2;
        r3 = r18 >> numDefine2;
        heapClassInst.heap32[r2] = heapClassInst.heap32[r4];
        r2 = r8 >> numDefine2;
        r4 = r19 >> numDefine2;
        heapClassInst.heap32[r1] = heapClassInst.heap32[r3];
        r1 = r9 >> numDefine2;
        r3 = r20 >> numDefine2;
        heapClassInst.heap32[r2] = heapClassInst.heap32[r4];
        r2 = r10 >> numDefine2;
        r4 = r21 >> numDefine2;
        heapClassInst.heap32[r1] = heapClassInst.heap32[r3];
        r1 = r11 >> numDefine2;
        r3 = r22 >> numDefine2;
        heapClassInst.heap32[r2] = heapClassInst.heap32[r4];
        r2 = r12 >> numDefine2;
        r4 = r23 >> numDefine2;
        heapClassInst.heap32[r1] = heapClassInst.heap32[r3];
        r1 = r13 >> numDefine2;
        r3 = heapClassInst.heap32[fp + numDefineNeg10];
        r3 = r3 >> numDefine2;
        heapClassInst.heap32[r2] = heapClassInst.heap32[r4];
        r2 = r14 >> numDefine2;
        r4 = heapClassInst.heap32[fp + numDefineNeg4];
        r4 = r4 >> numDefine2;
        heapClassInst.heap32[r1] = heapClassInst.heap32[r3];
        r1 = heapClassInst.heap32[fp + numDefineNeg5];
        r1 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[fp + numDefineNeg7];
        r3 = r3 >> numDefine2;
        heapClassInst.heap32[r2] = heapClassInst.heap32[r4];
        r2 = heapClassInst.heap32[fp + numDefineNeg3];
        r2 = r2 >> numDefine2;
        r4 = heapClassInst.heap32[fp + numDefineNeg6];
        r4 = r4 >> numDefine2;
        heapClassInst.heap32[r1] = heapClassInst.heap32[r3];
        r1 = heapClassInst.heap32[fp + numDefineNeg2];
        r1 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[fp + numDefineNeg9];
        r3 = r3 >> numDefine2;
        heapClassInst.heap32[r2] = heapClassInst.heap32[r4];
        r2 = heapClassInst.heap32[fp + -1];
        r2 = r2 >> numDefine2;
        r4 = heapClassInst.heap32[fp + numDefineNeg8];
        r4 = r4 >> numDefine2;
        heapClassInst.heap32[r1] = heapClassInst.heap32[r3];
        heapClassInst.heap32[r2] = heapClassInst.heap32[r4];
        heapClassInst.heap32[g0] = r0;
        zn11btRigidBody19updateInertiaTensorEv(i7);
        return;
    }

    public static void znk11btRigidBody28calculateSerializeBufferSizeEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = numDefine480;
        commonVariable.rg0 = r0;
        
    }

    public static void znk11btRigidBody21serializeSingleObjectEP12btSerializer(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = r0 >> numDefine2;
        r3 = r1 >> numDefine2;
        r4 = heapClassInst.heap32[r3];
        r5 = heapClassInst.heap32[r2];
        r4 = r4 >> numDefine2;
        r5 = r5 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + numDefine4];
        r5 = heapClassInst.heap32[r5 + numDefine4];
        heapClassInst.heap32[g0] = r0;
        functionTable.get(r5 >> numDefine2).accept(i7);
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
        heapClassInst.heap32[g0 + numDefine2] = 1;
        functionTable.get(r4 >> numDefine2).accept(i7);
        r4 = commonVariable.rg0;
        r2 = heapClassInst.heap32[r2];
        r2 = r2 >> numDefine2;
        r5 = r4 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine5];
        r5 = heapClassInst.heap32[r5 + numDefine2];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r5;
        heapClassInst.heap32[g0 + numDefine2] = r1;
        functionTable.get(r2 >> numDefine2).accept(i7);
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine5];
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = r4;
        heapClassInst.heap32[g0 + numDefine2] = commonVariable.rg0;
        heapClassInst.heap32[g0 + numDefine3] = (int) numDefine45650;
        heapClassInst.heap32[g0 + numDefine4] = r0;
        functionTable.get(r3 >> numDefine2).accept(i7);
        
    }

    public static void zn11btRigidBody24checkCollideWithOverrideEP17btCollisionObject(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heapU8[r0 + numDefine232];
        r1 = r1 & numDefine2;
        repeat1:
        do {
            if (r1 != 0) {
                if (r0 == 0) {
                    label = 1;
                } else {
                    r1 = heapClassInst.heap32[fp];
                    r1 = r1 >> numDefine2;
                    r2 = heapClassInst.heap32[r1 + numDefine120];
                    r3 = 0;
                    repeat4:
                    while (true) {
                        if (r2 > r3) {
                            r4 = heapClassInst.heap32[r1 + numDefine122];
                            r5 = r3 << numDefine2;
                            r4 = (r4 + r5) | 0;
                            r4 = r4 >> numDefine2;
                            r4 = heapClassInst.heap32[r4];
                            r4 = r4 >> numDefine2;
                            r5 = heapClassInst.heap32[r4 + numDefine5];
                            if (r5 != r0) {
                                r4 = heapClassInst.heap32[r4 + numDefine6];
                                if (r4 == r0) {
                                    break repeat4;
                                } else {
                                    r3 = (r3 + 1) | 0;
                                }
                            } else {
                                break repeat4;
                            }
                        } else {
                            label = 1;
                            break repeat1;
                        }
                    }
                    r0 = 0;
                    label = numDefine9;
                }
            } else {
                label = 1;
            }
        } while (false);
        if (label == 1) {
            r0 = 1;
        }
        r0 = r0 & numDefine255;
        commonVariable.rg0 = r0;
        
    }

    public static void zn11btRigidBodyD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv11btRigidBody;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = heapClassInst.heap32[r2 + numDefine120];
        if (r1 == 0) {
            r1 = heapClassInst.heap32[r2 + numDefine122];
            if (!(r1 == 0)) {
                r3 = heapClassInst.heapU8[r0 + numDefine492];
                if (!(r3 == 0)) {
                    r3 = gNumAlignedFree;
                    r3 = r3 >> numDefine2;
                    r4 = heapClassInst.heap32[r3];
                    r4 = (r4 + 1) | 0;
                    r1 = r1 >> numDefine2;
                    heapClassInst.heap32[r3] = r4;
                    r1 = heapClassInst.heap32[r1 + -1];
                    heapClassInst.heap32[g0] = r1;
                    free(i7);
                }
                heapClassInst.heap32[r2 + numDefine122] = 0;
            }
            r1 = 1;
            heapClassInst.heap8[r0 + numDefine492] = (byte) r1;
            heapClassInst.heap32[r2 + numDefine122] = 0;
            r1 = ztv17btCollisionObject;
            heapClassInst.heap32[r2 + numDefine120] = 0;
            r1 = (r1 + numDefine8) | 0;
            heapClassInst.heap32[r2 + numDefine121] = 0;
            heapClassInst.heap32[r2] = r1;
            if (!(r0 == 0)) {
                r0 = gNumAlignedFree;
                r0 = r0 >> numDefine2;
                r1 = heapClassInst.heap32[r0];
                r1 = (r1 + 1) | 0;
                heapClassInst.heap32[r0] = r1;
                r0 = heapClassInst.heap32[r2 + -1];
                heapClassInst.heap32[g0] = r0;
                free(i7);
            }
            
        } else {
            r0 = twoEStr248;
            r2 = twoEStr34955;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r2;
            heapClassInst.heap32[g0 + numDefine2] = numDefine175;
            assertNew(i7);
        }
        
    }

    public static void zn11btRigidBodyD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv11btRigidBody;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = heapClassInst.heap32[r2 + numDefine120];
        if (r1 == 0) {
            r1 = heapClassInst.heap32[r2 + numDefine122];
            if (!(r1 == 0)) {
                r3 = heapClassInst.heapU8[r0 + numDefine492];
                if (!(r3 == 0)) {
                    r3 = gNumAlignedFree;
                    r3 = r3 >> numDefine2;
                    r4 = heapClassInst.heap32[r3];
                    r4 = (r4 + 1) | 0;
                    r1 = r1 >> numDefine2;
                    heapClassInst.heap32[r3] = r4;
                    r1 = heapClassInst.heap32[r1 + -1];
                    heapClassInst.heap32[g0] = r1;
                    free(i7);
                }
                heapClassInst.heap32[r2 + numDefine122] = 0;
            }
            r1 = 1;
            heapClassInst.heap8[r0 + numDefine492] = (byte) r1;
            heapClassInst.heap32[r2 + numDefine122] = 0;
            r0 = ztv17btCollisionObject;
            heapClassInst.heap32[r2 + numDefine120] = 0;
            r0 = (r0 + numDefine8) | 0;
            heapClassInst.heap32[r2 + numDefine121] = 0;
            heapClassInst.heap32[r2] = r0;
            
        } else {
            r0 = twoEStr248;
            r2 = twoEStr34955;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r2;
            heapClassInst.heap32[g0 + numDefine2] = numDefine175;
            assertNew(i7);
        }
        
    }

    public static void znk11btRigidBody9serializeEPvP12btSerializer(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = r2;
        r1 = r1 >> numDefine2;
        r2 = r0 >> numDefine2;
        znk17btCollisionObject9serializeEPvP12btSerializer(i7);
        heapClassInst.heap32[r1 + numDefine62] = heapClassInst.heap32[r2 + numDefine64];
        heapClassInst.heap32[r1 + numDefine63] = heapClassInst.heap32[r2 + numDefine65];
        heapClassInst.heap32[r1 + numDefine64] = heapClassInst.heap32[r2 + numDefine66];
        heapClassInst.heap32[r1 + numDefine65] = heapClassInst.heap32[r2 + numDefine67];
        heapClassInst.heap32[r1 + numDefine66] = heapClassInst.heap32[r2 + numDefine68];
        heapClassInst.heap32[r1 + numDefine67] = heapClassInst.heap32[r2 + numDefine69];
        heapClassInst.heap32[r1 + numDefine68] = heapClassInst.heap32[r2 + numDefine70];
        heapClassInst.heap32[r1 + numDefine69] = heapClassInst.heap32[r2 + numDefine71];
        heapClassInst.heap32[r1 + numDefine70] = heapClassInst.heap32[r2 + numDefine72];
        heapClassInst.heap32[r1 + numDefine71] = heapClassInst.heap32[r2 + numDefine73];
        heapClassInst.heap32[r1 + numDefine72] = heapClassInst.heap32[r2 + numDefine74];
        heapClassInst.heap32[r1 + numDefine73] = heapClassInst.heap32[r2 + numDefine75];
        heapClassInst.heap32[r1 + numDefine74] = heapClassInst.heap32[r2 + numDefine76];
        heapClassInst.heap32[r1 + numDefine75] = heapClassInst.heap32[r2 + numDefine77];
        heapClassInst.heap32[r1 + numDefine76] = heapClassInst.heap32[r2 + numDefine78];
        heapClassInst.heap32[r1 + numDefine77] = heapClassInst.heap32[r2 + numDefine79];
        heapClassInst.heap32[r1 + numDefine78] = heapClassInst.heap32[r2 + numDefine80];
        heapClassInst.heap32[r1 + numDefine79] = heapClassInst.heap32[r2 + numDefine81];
        heapClassInst.heap32[r1 + numDefine80] = heapClassInst.heap32[r2 + numDefine82];
        heapClassInst.heap32[r1 + numDefine81] = heapClassInst.heap32[r2 + numDefine83];
        heapClassInst.heap32[r1 + numDefine110] = heapClassInst.heap32[r2 + numDefine84];
        heapClassInst.heap32[r1 + numDefine82] = heapClassInst.heap32[r2 + numDefine134];
        heapClassInst.heap32[r1 + numDefine83] = heapClassInst.heap32[r2 + numDefine135];
        heapClassInst.heap32[r1 + numDefine84] = heapClassInst.heap32[r2 + numDefine136];
        heapClassInst.heap32[r1 + numDefine85] = heapClassInst.heap32[r2 + numDefine137];
        heapClassInst.heap32[r1 + numDefine86] = heapClassInst.heap32[r2 + numDefine85];
        heapClassInst.heap32[r1 + numDefine87] = heapClassInst.heap32[r2 + numDefine86];
        heapClassInst.heap32[r1 + numDefine88] = heapClassInst.heap32[r2 + numDefine87];
        heapClassInst.heap32[r1 + numDefine89] = heapClassInst.heap32[r2 + numDefine88];
        heapClassInst.heap32[r1 + numDefine90] = heapClassInst.heap32[r2 + numDefine89];
        heapClassInst.heap32[r1 + numDefine91] = heapClassInst.heap32[r2 + numDefine90];
        heapClassInst.heap32[r1 + numDefine92] = heapClassInst.heap32[r2 + numDefine91];
        heapClassInst.heap32[r1 + numDefine93] = heapClassInst.heap32[r2 + numDefine92];
        heapClassInst.heap32[r1 + numDefine94] = heapClassInst.heap32[r2 + numDefine93];
        heapClassInst.heap32[r1 + numDefine95] = heapClassInst.heap32[r2 + numDefine94];
        heapClassInst.heap32[r1 + numDefine96] = heapClassInst.heap32[r2 + numDefine95];
        heapClassInst.heap32[r1 + numDefine97] = heapClassInst.heap32[r2 + numDefine96];
        heapClassInst.heap32[r1 + numDefine98] = heapClassInst.heap32[r2 + numDefine97];
        heapClassInst.heap32[r1 + numDefine99] = heapClassInst.heap32[r2 + numDefine98];
        heapClassInst.heap32[r1 + numDefine100] = heapClassInst.heap32[r2 + numDefine99];
        heapClassInst.heap32[r1 + numDefine101] = heapClassInst.heap32[r2 + numDefine100];
        heapClassInst.heap32[r1 + numDefine102] = heapClassInst.heap32[r2 + numDefine101];
        heapClassInst.heap32[r1 + numDefine103] = heapClassInst.heap32[r2 + numDefine102];
        heapClassInst.heap32[r1 + numDefine104] = heapClassInst.heap32[r2 + numDefine103];
        heapClassInst.heap32[r1 + numDefine105] = heapClassInst.heap32[r2 + numDefine104];
        heapClassInst.heap32[r1 + numDefine106] = heapClassInst.heap32[r2 + numDefine105];
        heapClassInst.heap32[r1 + numDefine107] = heapClassInst.heap32[r2 + numDefine106];
        heapClassInst.heap32[r1 + numDefine108] = heapClassInst.heap32[r2 + numDefine107];
        heapClassInst.heap32[r1 + numDefine109] = heapClassInst.heap32[r2 + numDefine108];
        heapClassInst.heap32[r1 + numDefine111] = heapClassInst.heap32[r2 + numDefine109];
        heapClassInst.heap32[r1 + numDefine112] = heapClassInst.heap32[r2 + numDefine110];
        r0 = heapClassInst.heapU8[r0 + numDefine444];
        heapClassInst.heap32[r1 + numDefine119] = r0;
        heapClassInst.heap32[r1 + numDefine113] = heapClassInst.heap32[r2 + numDefine112];
        heapClassInst.heap32[r1 + numDefine114] = heapClassInst.heap32[r2 + numDefine113];
        heapClassInst.heap32[r1 + numDefine115] = heapClassInst.heap32[r2 + numDefine114];
        heapClassInst.heap32[r1 + numDefine116] = heapClassInst.heap32[r2 + numDefine115];
        heapClassInst.heap32[r1 + numDefine117] = heapClassInst.heap32[r2 + numDefine116];
        heapClassInst.heap32[r1 + numDefine118] = heapClassInst.heap32[r2 + numDefine117];
        r0 = twoEStr414;
        commonVariable.rg0 = r0;
        
    }

    static void zn11btRigidBody16addConstraintRefEP17btTypedConstraint(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[fp + 1];
        r3 = heapClassInst.heap32[r1 + numDefine120];
        r4 = 0;
        repeat1:
        while (true) {
            if (r3 > r4) {
                r5 = heapClassInst.heap32[r1 + numDefine122];
                r6 = r4 << numDefine2;
                r5 = (r5 + r6) | 0;
                r5 = r5 >> numDefine2;
                r5 = heapClassInst.heap32[r5];
                if (r5 != r2) {
                    r4 = (r4 + 1) | 0;
                    continue repeat1;
                } else {
                    label = numDefine5;
                    break repeat1;
                }
            } else {
                label = numDefine4;
                break repeat1;
            }
        }
        if (label == numDefine4) {
            r4 = r3;
        }
        if (!(r3 != r4)) {
            r4 = heapClassInst.heap32[r1 + numDefine121];
            if (r4 == r3) {
                r5 = 1;
                r6 = r3 << 1;
                r6 = r3 == 0 ? r5 : r6;
                if (!(r4 >= r6)) {
                    if (r6 != 0) {
                        r4 = gNumAlignedAllocs;
                        r4 = r4 >> numDefine2;
                        r7 = heapClassInst.heap32[r4];
                        r8 = r6 << numDefine2;
                        r7 = (r7 + 1) | 0;
                        r8 = r8 | numDefine3;
                        heapClassInst.heap32[r4] = r7;
                        r4 = (r8 + numDefine16) | 0;
                        heapClassInst.heap32[g0] = r4;
                        mallocNew(i7);
                        r4 = commonVariable.rg0;
                        if (r4 != 0) {
                            r7 = 0;
                            r8 = (r4 + numDefine4) | 0;
                            r7 = (r7 - r8) | 0;
                            r7 = r7 & numDefine15;
                            r7 = (r4 + r7) | 0;
                            r8 = (r7 + numDefine4) | 0;
                            r7 = r7 >> numDefine2;
                            heapClassInst.heap32[r7] = r4;
                            r4 = r8;
                        }
                    } else {
                        r4 = 0;
                    }
                    repeat18:
                    do {
                        if (r3 < 1) {
                            r8 = heapClassInst.heap32[r1 + numDefine122];
                        } else {
                            r7 = 0;
                            while (true) {
                                r8 = heapClassInst.heap32[r1 + numDefine122];
                                r9 = r7 << numDefine2;
                                r10 = (r8 + r9) | 0;
                                r10 = r10 >> numDefine2;
                                r9 = (r4 + r9) | 0;
                                r10 = heapClassInst.heap32[r10];
                                r7 = (r7 + 1) | 0;
                                r9 = r9 >> numDefine2;
                                heapClassInst.heap32[r9] = r10;
                                if (!(r3 != r7)) {
                                    break repeat18;
                                }
                            }
                        }
                    } while (false);
                    if (r8 != 0) {
                        r7 = heapClassInst.heapU8[r0 + numDefine492];
                        if (r7 != 0) {
                            r3 = gNumAlignedFree;
                            r3 = r3 >> numDefine2;
                            r7 = heapClassInst.heap32[r3];
                            r7 = (r7 + 1) | 0;
                            r8 = r8 >> numDefine2;
                            heapClassInst.heap32[r3] = r7;
                            r3 = heapClassInst.heap32[r8 + -1];
                            heapClassInst.heap32[g0] = r3;
                            free(i7);
                            r3 = heapClassInst.heap32[r1 + numDefine120];
                        }
                        heapClassInst.heap32[r1 + numDefine122] = 0;
                    }
                    heapClassInst.heap8[r0 + numDefine492] = (byte) r5;
                    heapClassInst.heap32[r1 + numDefine122] = r4;
                    heapClassInst.heap32[r1 + numDefine121] = r6;
                }
            }
            r0 = r3 << numDefine2;
            r3 = heapClassInst.heap32[r1 + numDefine122];
            r0 = (r3 + r0) | 0;
            r0 = r0 >> numDefine2;
            heapClassInst.heap32[r0] = r2;
            r0 = heapClassInst.heap32[r1 + numDefine120];
            r0 = (r0 + 1) | 0;
            heapClassInst.heap32[r1 + numDefine120] = r0;
        }
        heapClassInst.heap32[r1 + numDefine63] = 1;
        return;
    }

    static void zn11btRigidBody19integrateVelocitiesEf(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heapU8[r0 + numDefine204];
        r1 = r1 & numDefine3;
        if (!(r1 != 0)) {
            f0 = heapClassInst.heapFloat[fp + 1];
            r0 = r0 >> numDefine2;
            f1 = heapClassInst.heapFloat[r0 + numDefine84];
            f1 = f1 * f0;
            f2 = heapClassInst.heapFloat[r0 + numDefine101];
            f3 = heapClassInst.heapFloat[r0 + numDefine103];
            f4 = heapClassInst.heapFloat[r0 + numDefine102];
            f5 = heapClassInst.heapFloat[r0 + numDefine76];
            f2 = f2 * f1;
            f2 = f5 + f2;
            heapClassInst.heapFloat[r0 + numDefine76] = f2;
            f2 = f4 * f1;
            f4 = heapClassInst.heapFloat[r0 + numDefine77];
            f2 = f4 + f2;
            heapClassInst.heapFloat[r0 + numDefine77] = f2;
            f1 = f3 * f1;
            f2 = heapClassInst.heapFloat[r0 + numDefine78];
            f1 = f2 + f1;
            heapClassInst.heapFloat[r0 + numDefine78] = f1;
            f1 = heapClassInst.heapFloat[r0 + numDefine105];
            f2 = heapClassInst.heapFloat[r0 + numDefine64];
            f3 = heapClassInst.heapFloat[r0 + numDefine106];
            f4 = heapClassInst.heapFloat[r0 + numDefine65];
            f2 = f2 * f1;
            f4 = f4 * f3;
            f5 = heapClassInst.heapFloat[r0 + numDefine107];
            f6 = heapClassInst.heapFloat[r0 + numDefine66];
            f2 = f2 + f4;
            f4 = f6 * f5;
            f2 = f2 + f4;
            f4 = heapClassInst.heapFloat[r0 + numDefine68];
            f6 = heapClassInst.heapFloat[r0 + numDefine69];
            f7 = heapClassInst.heapFloat[r0 + numDefine72];
            f8 = heapClassInst.heapFloat[r0 + numDefine73];
            f9 = heapClassInst.heapFloat[r0 + numDefine74];
            f10 = heapClassInst.heapFloat[r0 + numDefine70];
            f11 = heapClassInst.heapFloat[r0 + numDefine80];
            f2 = f2 * f0;
            f4 = f4 * f1;
            f6 = f6 * f3;
            f2 = f11 + f2;
            f4 = f4 + f6;
            f6 = f10 * f5;
            f4 = f4 + f6;
            heapClassInst.heapFloat[r0 + numDefine80] = f2;
            f1 = f7 * f1;
            f3 = f8 * f3;
            f4 = f4 * f0;
            f6 = heapClassInst.heapFloat[r0 + numDefine81];
            f4 = f6 + f4;
            f1 = f1 + f3;
            f3 = f9 * f5;
            f1 = f1 + f3;
            heapClassInst.heapFloat[r0 + numDefine81] = f4;
            f1 = f1 * f0;
            f3 = heapClassInst.heapFloat[r0 + numDefine82];
            f1 = f3 + f1;
            f2 = f2 * f2;
            f3 = f4 * f4;
            heapClassInst.heapFloat[r0 + numDefine82] = f1;
            f2 = f2 + f3;
            f1 = f1 * f1;
            f1 = f2 + f1;
            heapClassInst.heapFloat[g0] = f1;
            sqrtf(i7);
            f1 = (float) commonVariable.fg0;
            f2 = f1 * f0;
            f3 = (float) numDefineFloat566;
            if (!(f2 <= f3)) {
                f0 = f3 / f0;
                f0 = f0 / f1;
                f1 = heapClassInst.heapFloat[r0 + numDefine80];
                f1 = f1 * f0;
                heapClassInst.heapFloat[r0 + numDefine80] = f1;
                f1 = heapClassInst.heapFloat[r0 + numDefine81];
                f1 = f1 * f0;
                heapClassInst.heapFloat[r0 + numDefine81] = f1;
                f1 = heapClassInst.heapFloat[r0 + numDefine82];
                f0 = f1 * f0;
                heapClassInst.heapFloat[r0 + numDefine82] = f0;
            }
        }
        return;
    }

    static void zn11btRigidBody12applyDampingEf(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        f0 = heapClassInst.heapFloat[r1 + numDefine109];
        f1 = 1;
        f2 = heapClassInst.heapFloat[fp + 1];
        f0 = f1 - f0;
        heapClassInst.heapFloat[g0] = f0;
        heapClassInst.heapFloat[g0 + 1] = f2;
        powf(i7);
        f3 = heapClassInst.heapFloat[r1 + numDefine76];
        f3 = (float) (f3 * commonVariable.fg0);
        heapClassInst.heapFloat[r1 + numDefine76] = f3;
        f3 = heapClassInst.heapFloat[r1 + numDefine77];
        f3 = (float) (f3 * commonVariable.fg0);
        heapClassInst.heapFloat[r1 + numDefine77] = f3;
        f3 = heapClassInst.heapFloat[r1 + numDefine78];
        f0 = (float) (f3 * commonVariable.fg0);
        heapClassInst.heapFloat[r1 + numDefine78] = f0;
        f0 = heapClassInst.heapFloat[r1 + numDefine110];
        f0 = f1 - f0;
        heapClassInst.heapFloat[g0] = f0;
        heapClassInst.heapFloat[g0 + 1] = f2;
        powf(i7);
        f2 = heapClassInst.heapFloat[r1 + numDefine80];
        f2 = (float) (f2 * commonVariable.fg0);
        heapClassInst.heapFloat[r1 + numDefine80] = f2;
        f3 = heapClassInst.heapFloat[r1 + numDefine81];
        f3 = (float) (f3 * commonVariable.fg0);
        heapClassInst.heapFloat[r1 + numDefine81] = f3;
        f4 = heapClassInst.heapFloat[r1 + numDefine82];
        f0 = (float) (f4 * commonVariable.fg0);
        heapClassInst.heapFloat[r1 + numDefine82] = f0;
        r0 = heapClassInst.heapU8[r0 + numDefine444];
        if (!(r0 == 0)) {
            f4 = f2 * f2;
            f5 = f3 * f3;
            f6 = heapClassInst.heapFloat[r1 + numDefine76];
            f4 = f4 + f5;
            f5 = f0 * f0;
            f4 = f4 + f5;
            f5 = heapClassInst.heapFloat[r1 + numDefine114];
            if (f4 < f5) {
                f4 = heapClassInst.heapFloat[r1 + numDefine77];
                f5 = heapClassInst.heapFloat[r1 + numDefine78];
                f7 = f6 * f6;
                f8 = f4 * f4;
                f7 = f7 + f8;
                f8 = f5 * f5;
                f7 = f7 + f8;
                f8 = heapClassInst.heapFloat[r1 + numDefine113];
                if (f7 < f8) {
                    f7 = heapClassInst.heapFloat[r1 + numDefine112];
                    f2 = f2 * f7;
                    f3 = f3 * f7;
                    heapClassInst.heapFloat[r1 + numDefine80] = f2;
                    f0 = f0 * f7;
                    heapClassInst.heapFloat[r1 + numDefine81] = f3;
                    f6 = f6 * f7;
                    heapClassInst.heapFloat[r1 + numDefine82] = f0;
                    f4 = f4 * f7;
                    heapClassInst.heapFloat[r1 + numDefine76] = f6;
                    f5 = f5 * f7;
                    heapClassInst.heapFloat[r1 + numDefine77] = f4;
                    heapClassInst.heapFloat[r1 + numDefine78] = f5;
                }
            } else {
                f4 = heapClassInst.heapFloat[r1 + numDefine77];
                f5 = heapClassInst.heapFloat[r1 + numDefine78];
            }
            f0 = f6 * f6;
            f2 = f4 * f4;
            f0 = f0 + f2;
            f2 = f5 * f5;
            f0 = f0 + f2;
            heapClassInst.heapFloat[g0] = f0;
            sqrtf(i7);
            f0 = (float) commonVariable.fg0;
            f2 = heapClassInst.heapFloat[r1 + numDefine109];
            if (!(f2 <= f0)) {
                f2 = (float) numDefineFloat091;
                if (f0 <= f2) {
                    heapClassInst.heap32[r1 + numDefine76] = 0;
                    heapClassInst.heap32[r1 + numDefine77] = 0;
                    heapClassInst.heap32[r1 + numDefine78] = 0;
                    heapClassInst.heap32[r1 + numDefine79] = 0;
                } else {
                    f0 = heapClassInst.heapFloat[r1 + numDefine76];
                    f3 = heapClassInst.heapFloat[r1 + numDefine77];
                    f4 = heapClassInst.heapFloat[r1 + numDefine78];
                    f0 = f0 * f0;
                    f3 = f3 * f3;
                    f0 = f0 + f3;
                    f3 = f4 * f4;
                    f0 = f0 + f3;
                    heapClassInst.heapFloat[g0] = f0;
                    sqrtf(i7);
                    f0 = (float) (f1 / commonVariable.fg0);
                    f3 = heapClassInst.heapFloat[r1 + numDefine76];
                    f4 = heapClassInst.heapFloat[r1 + numDefine77];
                    f5 = f3 * f0;
                    f6 = heapClassInst.heapFloat[r1 + numDefine78];
                    f7 = f4 * f0;
                    f5 = f5 * f2;
                    f0 = f6 * f0;
                    f7 = f7 * f2;
                    f3 = f3 - f5;
                    f0 = f0 * f2;
                    f2 = f4 - f7;
                    heapClassInst.heapFloat[r1 + numDefine76] = f3;
                    f0 = f6 - f0;
                    heapClassInst.heapFloat[r1 + numDefine77] = f2;
                    heapClassInst.heapFloat[r1 + numDefine78] = f0;
                }
            }
            f0 = heapClassInst.heapFloat[r1 + numDefine80];
            f2 = heapClassInst.heapFloat[r1 + numDefine81];
            f3 = heapClassInst.heapFloat[r1 + numDefine82];
            f0 = f0 * f0;
            f2 = f2 * f2;
            f0 = f0 + f2;
            f2 = f3 * f3;
            f0 = f0 + f2;
            heapClassInst.heapFloat[g0] = f0;
            sqrtf(i7);
            f0 = (float) commonVariable.fg0;
            f2 = heapClassInst.heapFloat[r1 + numDefine110];
            if (!(f2 <= f0)) {
                f2 = (float) numDefineFloat091;
                if (f0 <= f2) {
                    heapClassInst.heap32[r1 + numDefine80] = 0;
                    heapClassInst.heap32[r1 + numDefine81] = 0;
                    heapClassInst.heap32[r1 + numDefine82] = 0;
                    heapClassInst.heap32[r1 + numDefine83] = 0;
                } else {
                    f0 = heapClassInst.heapFloat[r1 + numDefine80];
                    f3 = heapClassInst.heapFloat[r1 + numDefine81];
                    f4 = heapClassInst.heapFloat[r1 + numDefine82];
                    f0 = f0 * f0;
                    f3 = f3 * f3;
                    f0 = f0 + f3;
                    f3 = f4 * f4;
                    f0 = f0 + f3;
                    heapClassInst.heapFloat[g0] = f0;
                    sqrtf(i7);
                    f0 = (float) (f1 / commonVariable.fg0);
                    f1 = heapClassInst.heapFloat[r1 + numDefine80];
                    f3 = heapClassInst.heapFloat[r1 + numDefine81];
                    f4 = f1 * f0;
                    f5 = heapClassInst.heapFloat[r1 + numDefine82];
                    f6 = f3 * f0;
                    f4 = f4 * f2;
                    f0 = f5 * f0;
                    f6 = f6 * f2;
                    f1 = f1 - f4;
                    f0 = f0 * f2;
                    f2 = f3 - f6;
                    heapClassInst.heapFloat[r1 + numDefine80] = f1;
                    f0 = f5 - f0;
                    heapClassInst.heapFloat[r1 + numDefine81] = f2;
                    heapClassInst.heapFloat[r1 + numDefine82] = f0;
                    return;
                }
            }
        }
        return;
    }

    public static void globalIzn7btClockC2Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = zl13gProfileClock2E0;
        heapClassInst.heap32[g0] = numDefine8;
        r0 = r0 >> numDefine2;
        znwj(i7);
        heapClassInst.heap32[r0] = commonVariable.rg0;
        heapClassInst.heap32[g0] = commonVariable.rg0;
        heapClassInst.heap32[g0 + 1] = 0;
        r0 = zn15CProfileManager4RootE;
        r1 = r0 >> numDefine2;
        r2 = twoEStr729;
        getTimeOfDay(i7);
        heapClassInst.heap32[r1] = r2;
        heapClassInst.heap32[r1 + 1] = 0;
        heapClassInst.heap32[r1 + numDefine2] = 0;
        heapClassInst.heap32[r1 + numDefine3] = 0;
        heapClassInst.heap32[r1 + numDefine4] = 0;
        heapClassInst.heap32[r1 + numDefine5] = 0;
        heapClassInst.heap32[r1 + numDefine6] = 0;
        heapClassInst.heap32[r1 + numDefine7] = 0;
        heapClassInst.heap32[g0] = r0;
        zn12CProfileNode5ResetEv(i7);
        
    }

    public static void globalDzn7btClockC2Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = zn15CProfileManager4RootE;
        r1 = zl13gProfileClock2E0;
        heapClassInst.heap32[g0] = r0;
        r0 = r1 >> numDefine2;
        zn12CProfileNodeD1Ev(i7);
        r0 = heapClassInst.heap32[r0];
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    static void zn12CProfileNodeD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + numDefine6];
        if (!(r1 == 0)) {
            heapClassInst.heap32[g0] = r1;
            zn12CProfileNodeD1Ev(i7);
            heapClassInst.heap32[g0] = r1;
            zdlPv(i7);
        }
        r0 = heapClassInst.heap32[r0 + numDefine7];
        if (!(r0 == 0)) {
            heapClassInst.heap32[g0] = r0;
            zn12CProfileNodeD1Ev(i7);
            heapClassInst.heap32[g0] = r0;
            zdlPv(i7);
        }
        return;
    }

    static void zn15CProfileManager5ResetEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = zl13gProfileClock2E0;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = 0;
        getTimeOfDay(i7);
        r1 = zn15CProfileManager4RootE;
        heapClassInst.heap32[g0] = r1;
        r1 = r1 >> numDefine2;
        zn12CProfileNode5ResetEv(i7);
        r2 = heapClassInst.heap32[r1 + 1];
        r2 = (r2 + 1) | 0;
        heapClassInst.heap32[r1 + 1] = r2;
        r2 = heapClassInst.heap32[r1 + numDefine4];
        r3 = (r2 + 1) | 0;
        heapClassInst.heap32[r1 + numDefine4] = r3;
        if (!(r2 != 0)) {
            r2 = sp + numDefineNeg16;
            heapClassInst.heap32[g0] = r2;
            heapClassInst.heap32[g0 + 1] = 0;
            getTimeOfDay(i7);
            r0 = heapClassInst.heap32[r0];
            r0 = r0 >> numDefine2;
            r2 = r2 >> numDefine2;
            r3 = heapClassInst.heap32[fp + numDefineNeg4];
            r4 = heapClassInst.heap32[r0];
            r3 = (r3 - r4) | 0;
            r2 = heapClassInst.heap32[r2 + 1];
            r0 = heapClassInst.heap32[r0 + 1];
            r0 = (r2 - r0) | 0;
            r2 = (int) ((r3 * numDefineN6) | 0);
            r0 = (r0 + r2) | 0;
            heapClassInst.heap32[r1 + numDefine3] = r0;
        }
        r0 = zn15CProfileManager12FrameCounterE;
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r0] = 0;
        r0 = sp + numDefineNeg8;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = 0;
        getTimeOfDay(i7);
        return;
    }

    public static void globalIzn4Rw9CatfindEPNS8RwCatE(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = zn4RwL12RwCatlistE2E0;
        r1 = zn4RwL12RwCatlistE2E1;
        r0 = r0 >> numDefine2;
        r2 = zn4RwL12RwCatlistE2E2;
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r0] = 0;
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r1] = 0;
        heapClassInst.heap32[r2] = 0;
        heapClassInst.heap32[g0] = numDefine136;
        znwj(i7);
        r3 = commonVariable.rg0;
        if (!(r3 != 0)) {
            heapClassInst.heap32[g0] = numDefine3;
            zn4Rw10RwThrowEiz(i7);
        }
        r4 = (r3 + numDefine136) | 0;
        heapClassInst.heap32[g0] = 0;
        zdlPv(i7);
        r5 = heapClassInst.heap32[r0];
        if (r5 == 0) {
            r8 = r3;
        } else {
            r6 = r5;
            r7 = r3;
            repeat9:
            while (true) {
                r9 = r6 >> numDefine2;
                r6 = (r6 + numDefine4) | 0;
                r8 = (r7 + numDefine4) | 0;
                r7 = r7 >> numDefine2;
                r9 = heapClassInst.heap32[r9];
                heapClassInst.heap32[r7] = r9;
                r7 = r8;
                if (r6 != 0) {
                    continue repeat9;
                } else {
                    break repeat9;
                }
            }
        }
        r6 = 0;
        repeat12:
        while (true) {
            r7 = r6 << numDefine2;
            r7 = (r8 + r7) | 0;
            r6 = (r6 + 1) | 0;
            r7 = r7 >> numDefine2;
            heapClassInst.heap32[r7] = 0;
            if (r6 != numDefine2) {
                continue repeat12;
            } else {
                break repeat12;
            }
        }
        r6 = heapClassInst.heap32[r1];
        if (r6 == 0) {
            r6 = (r8 + numDefine8) | 0;
            heapClassInst.heap32[r0] = r3;
            heapClassInst.heap32[r1] = r6;
            heapClassInst.heap32[r2] = r4;
            heapClassInst.heap32[g0] = r5;
            zdlPv(i7);
            
        } else {
            abort(i7);
        }
        
    }

    public static Objects globalDzn4Rw9CatfindEPNS8RwCatE(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = zn4RwL12RwCatlistE2E0;
        r1 = zn4RwL12RwCatlistE2E1;
        r0 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        r0 = heapClassInst.heap32[r0];
        r2 = heapClassInst.heap32[r1];
        r3 = (r2 - r0) | 0;
        r3 = r3 >> numDefine2;
        if (!(r3 == 0)) {
            r3 = r3 << numDefine2;
            r2 = (r2 - r3) | 0;
            heapClassInst.heap32[r1] = r2;
        }
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }

    public static void zn4Rw10RwFacetD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztvn4Rw10RwFacetE;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        heapClassInst.heap32[r0 + numDefine5] = -1;
        r1 = heapClassInst.heap32[r0 + 1];
        r2 = heapClassInst.heap32[r0 + numDefine2];
        if (!(r1 == r2)) {
            if (!(r1 == 0)) {
                heapClassInst.heap32[g0] = r1;
                zdaPv(i7);
            }
        }
        r1 = zzn4Rw10RwFacetD4EvE9destroyed;
        heapClassInst.heap32[r0 + 1] = r1;
        r1 = heapClassInst.heap32[r0 + numDefine4];
        if (!(r1 != -1)) {
            r0 = heapClassInst.heap32[r0 + numDefine3];
            heapClassInst.heap32[g0] = r0;
            zdlPv(i7);
        }
        
    }

    public static void zn4Rw10RwFacetD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztvn4Rw10RwFacetE;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[r2 + numDefine5] = -1;
        r1 = heapClassInst.heap32[r2 + 1];
        r3 = heapClassInst.heap32[r2 + numDefine2];
        if (!(r1 == r3)) {
            if (!(r1 == 0)) {
                heapClassInst.heap32[g0] = r1;
                zdaPv(i7);
            }
        }
        r1 = zzn4Rw10RwFacetD4EvE9destroyed;
        heapClassInst.heap32[r2 + 1] = r1;
        r1 = heapClassInst.heap32[r2 + numDefine4];
        if (!(r1 != -1)) {
            r1 = heapClassInst.heap32[r2 + numDefine3];
            heapClassInst.heap32[g0] = r1;
            zdlPv(i7);
        }
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        
    }
}
